Normal tenglama va gradient descent

import pandas as pd
import numpy as np
import time

df = pd.read_csv(DATA / "uy_ijara.csv")
son = ["xonalar", "maydon_m2", "metro_km", "mebel"]
X_xom = df[son].to_numpy(dtype=float)
y = df["narx_usd"].to_numpy(dtype=float)

# bias uchun birlar ustunini qo'shamiz
X = np.c_[np.ones(len(X_xom)), X_xom]
print(f"X shakli (bias ustuni bilan): {X.shape}")
print(X[:3].round(2))

def normal_tenglama(X, y):
    return np.linalg.inv(X.T @ X) @ X.T @ y

t0 = time.perf_counter()
teta = normal_tenglama(X, y)
nt_vaqt = time.perf_counter() - t0

print("Normal tenglama natijasi:")
print(f"  bias (b)  : {teta[0]:>8.3f}")
for nom, v in zip(son, teta[1:]):
    print(f"  {nom:10s}: {v:>8.3f}")
print()
print(f"Hisoblash vaqti: {nt_vaqt*1000:.3f} ms  —  BITTA urinishda")

from sklearn.linear_model import LinearRegression

lr = LinearRegression().fit(X_xom, y)
taqqos = pd.DataFrame({
    "parametr": ["bias"] + son,
    "normal tenglama": np.round(teta, 4),
    "sklearn": np.round(np.r_[lr.intercept_, lr.coef_], 4),
})
taqqos["farq"] = (taqqos["normal tenglama"] - taqqos["sklearn"]).abs().round(10)
show(taqqos)
print()
print("Bir xilmi:", bool(np.allclose(teta, np.r_[lr.intercept_, lr.coef_])))

from sklearn.preprocessing import StandardScaler

def mse(X, y, teta):
    return float(np.mean((X @ teta - y) ** 2))

def gd(X, y, alpha, qadamlar):
    teta = np.zeros(X.shape[1])
    for _ in range(qadamlar):
        grad = (2 / len(y)) * X.T @ (X @ teta - y)
        teta = teta - alpha * grad
    return teta

# shkalalangan ma'lumotda GD yaxshi ishlaydi (12-bob)
Xs_xom = StandardScaler().fit_transform(X_xom)
Xs = np.c_[np.ones(len(Xs_xom)), Xs_xom]

teta_nt_s = normal_tenglama(Xs, y)
print(f"{'usul':<28} {'MSE':>12} {'vaqt (ms)':>11}")
print("-" * 53)
t0 = time.perf_counter(); tn = normal_tenglama(Xs, y); tv = (time.perf_counter()-t0)*1000
print(f"{'Normal tenglama':<28} {mse(Xs, y, tn):>12,.1f} {tv:>11.3f}".replace(",", " "))
for n in [100, 1000, 10000]:
    t0 = time.perf_counter(); tg = gd(Xs, y, 0.1, n); tv = (time.perf_counter()-t0)*1000
    print(f"{'GD (' + str(n) + ' qadam)':<28} {mse(Xs, y, tg):>12,.1f} {tv:>11.3f}".replace(",", " "))

print("Ustunlar soni oshganda normal tenglama qancha vaqt oladi:")
print(f"{'ustunlar':>10} {'X.T@X shakli':>16} {'normal tenglama':>18} {'GD (200 qadam)':>17}")
print("-" * 66)
r = np.random.default_rng(42)
for m in [10, 100, 500, 1500]:
    n = 3000
    Xb = r.normal(size=(n, m))
    yb = Xb @ r.normal(size=m) + r.normal(scale=.5, size=n)
    t0 = time.perf_counter(); normal_tenglama(Xb, yb); nt = (time.perf_counter()-t0)*1000
    t0 = time.perf_counter(); gd(Xb, yb, 0.01, 200); gt = (time.perf_counter()-t0)*1000
    print(f"{m:>10} {f'{m}x{m}':>16} {nt:>15.1f} ms {gt:>14.1f} ms")

# ikki ustun BIR XIL (to'liq korrelyatsiya) — real ma'lumotda ham uchraydi
X_buzuq = np.c_[np.ones(100), r.normal(size=100)]
X_buzuq = np.c_[X_buzuq, X_buzuq[:, 1]]          # 3-ustun 2-ustunning nusxasi
y_buzuq = r.normal(size=100)

print(f"X shakli: {X_buzuq.shape}")
print(f"X.T @ X determinanti: {np.linalg.det(X_buzuq.T @ X_buzuq):.3e}   <- nolga juda yaqin")
print()
try:
    np.linalg.inv(X_buzuq.T @ X_buzuq)
    print("inv() ishladi (lekin natija ishonchsiz)")
except np.linalg.LinAlgError as e:
    print(f"inv() XATO berdi: {e}")
print()
print("YECHIM: pinv() — psevdo-teskari matritsa (sklearn ham shuni ishlatadi)")
teta_p = np.linalg.pinv(X_buzuq) @ y_buzuq
print(f"  pinv() ishladi, natija: {teta_p.round(4)}")

print("Bizning ma'lumotda uchta usul bir xil javob beradimi:")
t1 = np.linalg.inv(X.T @ X) @ X.T @ y
t2 = np.linalg.pinv(X) @ y
t3 = np.linalg.lstsq(X, y, rcond=None)[0]
print(f"  inv  : {t1.round(4)}")
print(f"  pinv : {t2.round(4)}")
print(f"  lstsq: {t3.round(4)}")
print(f"  Hammasi mos: {bool(np.allclose(t1, t2) and np.allclose(t2, t3))}")

show(pd.DataFrame([
    {"Xususiyat": "Iteratsiya", "Normal tenglama": "YO'Q — bir urinishda", "Gradient descent": "Minglab qadam"},
    {"Xususiyat": "Learning rate", "Normal tenglama": "KERAK EMAS", "Gradient descent": "Tanlash kerak, nozik"},
    {"Xususiyat": "Scaling", "Normal tenglama": "Kerak emas", "Gradient descent": "SHART (12-bob)"},
    {"Xususiyat": "Ustunlar ko'p (m > 10 000)", "Normal tenglama": "Juda sekin — O(m^3)", "Gradient descent": "Ishlaydi"},
    {"Xususiyat": "Qatorlar ko'p (n > 1 mln)", "Normal tenglama": "Xotira muammosi", "Gradient descent": "Mini-batch bilan ishlaydi"},
    {"Xususiyat": "Ma'lumot oqimda keladi", "Normal tenglama": "Ishlamaydi", "Gradient descent": "SGD bilan ishlaydi"},
    {"Xususiyat": "Multikollinearlik", "Normal tenglama": "inv() yiqiladi (pinv kerak)", "Gradient descent": "Ishlaydi"},
    {"Xususiyat": "Boshqa modellarga mos", "Normal tenglama": "FAQAT chiziqli + MSE", "Gradient descent": "Logistic, NN, boosting — hammasi"},
]))

show(pd.DataFrame([
    {"Model": "Linear Regression", "Yopiq formula bormi": "HA", "sklearn nimani ishlatadi": "lstsq (yopiq)"},
    {"Model": "Ridge", "Yopiq formula bormi": "HA", "sklearn nimani ishlatadi": "Yopiq yoki iterativ (solver=)"},
    {"Model": "Lasso", "Yopiq formula bormi": "YO'Q", "sklearn nimani ishlatadi": "Koordinata bo'yicha tushish"},
    {"Model": "Logistic Regression", "Yopiq formula bormi": "YO'Q", "sklearn nimani ishlatadi": "lbfgs / newton-cg (iterativ)"},
    {"Model": "Neyron tarmoq", "Yopiq formula bormi": "YO'Q", "sklearn nimani ishlatadi": "Mini-batch GD (Adam)"},
    {"Model": "XGBoost", "Yopiq formula bormi": "YO'Q", "sklearn nimani ishlatadi": "Gradient boosting"},
]))

show(pd.DataFrame([
    {"Holat": "Kichik ma'lumot, kam ustun", "Tanlov": "Normal tenglama (LinearRegression)"},
    {"Holat": "Ustunlar 10 000 dan ko'p", "Tanlov": "SGDRegressor yoki Ridge(solver='sag')"},
    {"Holat": "Qatorlar millionlab", "Tanlov": "SGDRegressor (mini-batch)"},
    {"Holat": "Ma'lumot oqimda keladi", "Tanlov": "SGDRegressor + partial_fit"},
    {"Holat": "Chiziqli bo'lmagan model", "Tanlov": "Boshqa yo'l yo'q — gradient descent"},
]))

from sklearn.linear_model import SGDRegressor
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score

print("Ikki sklearn modeli, bir xil ma'lumot:")
lr_ball = cross_val_score(LinearRegression(), Xs_xom, y, cv=5, scoring="r2")
sgd_ball = cross_val_score(SGDRegressor(max_iter=5000, tol=1e-4, random_state=42),
                           Xs_xom, y, cv=5, scoring="r2")
print(f"  LinearRegression (yopiq formula): R2 = {lr_ball.mean():.4f} ±{lr_ball.std():.4f}")
print(f"  SGDRegressor     (gradient desc): R2 = {sgd_ball.mean():.4f} ±{sgd_ball.std():.4f}")
print()
print(f"Farq: {abs(lr_ball.mean() - sgd_ball.mean()):.4f}  |  tarqalish: ±{max(lr_ball.std(), sgd_ball.std()):.4f}")
print("Hukm:", "farq tarqalish ichida — ikkisi ham bir xil javobga keladi"
      if abs(lr_ball.mean()-sgd_ball.mean()) < max(lr_ball.std(), sgd_ball.std())
      else "farq sezilarli")

show(pd.DataFrame([
    {"Tushuncha": "Normal tenglama", "Bitta jumla": "w = (X^T X)^-1 X^T y — bir urinishda aniq javob"},
    {"Tushuncha": "LinearRegression ichi", "Bitta jumla": "Gradient descent EMAS — yopiq yechim (lstsq)"},
    {"Tushuncha": "inv() xavfi", "Bitta jumla": "Multikollinearlikda yiqiladi — pinv() yoki lstsq() ishlat"},
    {"Tushuncha": "Normal tenglama narxi", "Bitta jumla": "O(m^3) — ustunlar ko'p bo'lsa qimmat"},
    {"Tushuncha": "GD narxi", "Bitta jumla": "Ustunlar bo'yicha chiziqli — katta m da arzonroq"},
    {"Tushuncha": "Nega GD universal", "Bitta jumla": "Yopiq formula faqat chiziqli+MSE uchun bor"},
]))