Cost funksiya va gradient descent

w = np.array([55.0, 7.5, -28.0, 90.0])

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

df = pd.read_csv(DATA / "uy_ijara.csv")
son = ["maydon_m2"]                      # avval BITTA xususiyat — ko'rish osonroq
X = df[son].to_numpy(dtype=float)
y = df["narx_usd"].to_numpy(dtype=float)

def bashorat(X, w, b):
    return X @ w + b

def mse(X, y, w, b):
    xato = bashorat(X, w, b) - y
    return float(np.mean(xato ** 2))

# ikki xil taxmin
for w_t, b_t in [(np.array([5.0]), 200.0), (np.array([7.5]), 180.0), (np.array([12.0]), 50.0)]:
    print(f"w={w_t[0]:>5.1f}  b={b_t:>5.0f}  ->  MSE = {mse(X, y, w_t, b_t):>12,.0f}".replace(",", " "))

show(pd.DataFrame([
    {"Sabab": "Ishorani yo'qotish", "Izoh": "+50 va -50 xato bir-birini yo'qotmasligi kerak"},
    {"Sabab": "Katta xatoni ko'proq jazolash", "Izoh": "10 birlik xato -> 100; 100 birlik -> 10 000"},
    {"Sabab": "Hosilasi oson", "Izoh": "Kvadratning hosilasi chiziqli — gradient hisoblash qulay"},
]))

w_oraliq = np.linspace(0, 20, 200)
xarajat = [mse(X, y, np.array([wi]), 180.0) for wi in w_oraliq]
eng_yaxshi_i = int(np.argmin(xarajat))

rasm, ax = plt.subplots(figsize=(9.5, 5))
ax.plot(w_oraliq, xarajat, "b-", lw=2)
ax.plot(w_oraliq[eng_yaxshi_i], xarajat[eng_yaxshi_i], "ro", ms=11,
        label=f"eng past: w={w_oraliq[eng_yaxshi_i]:.2f}")
ax.set_xlabel("w (maydon_m2 ning vazni)")
ax.set_ylabel("MSE (xarajat)")
ax.set_title("Cost funksiya — kosa shaklida", fontweight="bold")
ax.legend(); ax.grid(alpha=.3)
fig("kosa.png", caption="MSE kosa shaklida. Eng past nuqta — eng yaxshi vazn. Gradient descent shu nuqtaga tushadi.")

print(f"Eng past nuqta: w = {w_oraliq[eng_yaxshi_i]:.3f},  MSE = {xarajat[eng_yaxshi_i]:,.0f}".replace(",", " "))

def gradient(X, y, w, b):
    """MSE ning w va b bo'yicha hosilalari."""
    n = len(y)
    xato = bashorat(X, w, b) - y          # shakli (n,)
    dw = (2 / n) * (X.T @ xato)           # shakli (m,)
    db = (2 / n) * np.sum(xato)
    return dw, db

for wi in [3.0, 7.5, 15.0]:
    dw, db = gradient(X, y, np.array([wi]), 180.0)
    yonalish = "w ni OSHIRISH kerak" if dw[0] < 0 else "w ni KAMAYTIRISH kerak"
    print(f"w={wi:>5.1f}  ->  dw={dw[0]:>12,.1f}   {yonalish}".replace(",", " "))

def gradient_descent(X, y, alpha=0.0001, qadamlar=200):
    w = np.zeros(X.shape[1])
    b = 0.0
    tarix = []
    for i in range(qadamlar):
        dw, db = gradient(X, y, w, b)
        w = w - alpha * dw
        b = b - alpha * db
        tarix.append({"qadam": i, "w": float(w[0]), "b": b, "mse": mse(X, y, w, b)})
    return w, b, pd.DataFrame(tarix)

w_fin, b_fin, tarix = gradient_descent(X, y, alpha=0.0002, qadamlar=400)
show(tarix.iloc[[0, 1, 2, 5, 20, 100, 399]].round(3))

print(f"Boshlanish : w=0.000     MSE={tarix.mse.iloc[0]:>12,.0f}".replace(",", " "))
print(f"Yakun      : w={w_fin[0]:.3f}   MSE={tarix.mse.iloc[-1]:>12,.0f}".replace(",", " "))
print()
from sklearn.linear_model import LinearRegression
lr = LinearRegression().fit(X, y)
print(f"sklearn javobi: w={lr.coef_[0]:.3f}  b={lr.intercept_:.2f}")
print(f"Bizning javob : w={w_fin[0]:.3f}  b={b_fin:.2f}")

print("Shkalalanmagan ma'lumotda qancha qadam kerak:")
print(f"{'qadamlar':>10} {'w':>9} {'b':>10} {'MSE':>12}")
print("-" * 44)
for n in [400, 5000, 50000, 300000]:
    w_t, b_t, tr_t = gradient_descent(X, y, alpha=0.0002, qadamlar=n)
    mse_matn = f"{tr_t.mse.iloc[-1]:,.0f}".replace(",", " ")
    print(f"{n:>10} {w_t[0]:>9.3f} {b_t:>10.2f} {mse_matn:>12}")
print()
print(f"sklearn:   w={lr.coef_[0]:.3f}  b={lr.intercept_:.2f}")

rasm, axes = plt.subplots(1, 2, figsize=(14, 4.8))
axes[0].plot(tarix.qadam, tarix.mse, "b-", lw=2)
axes[0].set_xlabel("Qadam"); axes[0].set_ylabel("MSE")
axes[0].set_title("Xarajat qadamma-qadam tushadi", fontweight="bold")
axes[0].grid(alpha=.3)

axes[1].plot(w_oraliq, xarajat, "k-", lw=1.5, alpha=.5, label="cost funksiya")
qadamlar_ko = tarix.iloc[::12]
axes[1].plot(qadamlar_ko.w, [mse(X, y, np.array([wi]), 180.0) for wi in qadamlar_ko.w],
             "ro-", ms=5, lw=1, label="gradient descent yo'li")
axes[1].set_xlabel("w"); axes[1].set_ylabel("MSE")
axes[1].set_title("Kosa bo'ylab tushish", fontweight="bold")
axes[1].legend(); axes[1].grid(alpha=.3)
fig("gd_yoli.png", caption="Chapda: xarajat har qadamda kamayadi. O'ngda: shu qadamlar kosa ustida qanday ko'rinadi.")

print(f"{'alpha':>10} {'400 qadamdan keyin w':>22} {'MSE':>16} {'holat':>14}")
print("-" * 68)
for a in [0.000001, 0.00002, 0.0002, 0.001, 0.01]:
    w_t, b_t, tr = gradient_descent(X, y, alpha=a, qadamlar=400)
    m = tr.mse.iloc[-1]
    if not np.isfinite(m) or m > 1e12:
        holat, m_matn = "PORTLADI", "inf"
    elif abs(w_t[0] - lr.coef_[0]) < 0.5:
        holat, m_matn = "yaqinlashdi", f"{m:,.0f}".replace(",", " ")
    else:
        holat, m_matn = "juda sekin", f"{m:,.0f}".replace(",", " ")
    print(f"{a:>10} {w_t[0]:>22.3f} {m_matn:>16} {holat:>14}")
print()
print(f"sklearn ning javobi: w = {lr.coef_[0]:.3f}")

from sklearn.preprocessing import StandardScaler
Xs = StandardScaler().fit_transform(X)
print("Shkalalangan ma'lumotda ANCHA katta alpha ishlaydi:")
print(f"{'alpha':>8} {'w':>10} {'MSE':>14}")
print("-" * 34)
for a in [0.001, 0.01, 0.1, 0.5]:
    w_t, b_t, tr = gradient_descent(Xs, y, alpha=a, qadamlar=400)
    print(f"{a:>8} {w_t[0]:>10.2f} {tr.mse.iloc[-1]:>13,.0f}".replace(",", " "))

son4 = ["xonalar", "maydon_m2", "metro_km", "mebel"]
X4 = StandardScaler().fit_transform(df[son4].to_numpy(dtype=float))
w4, b4, tr4 = gradient_descent(X4, y, alpha=0.1, qadamlar=1500)

lr4 = LinearRegression().fit(X4, y)
taqqos = pd.DataFrame({
    "xususiyat": son4,
    "biz topdik": w4.round(2),
    "sklearn": lr4.coef_.round(2),
})
show(taqqos)
print(f"bias: biz {b4:.2f}  |  sklearn {lr4.intercept_:.2f}")
print(f"MSE : biz {tr4.mse.iloc[-1]:,.0f}  |  sklearn {mse(X4, y, lr4.coef_, lr4.intercept_):,.0f}".replace(",", " "))

show(pd.DataFrame([
    {"Turi": "Batch GD", "Har qadamda": "HAMMA qator", "Tezlik": "Sekin",
     "Yo'li": "Silliq", "Qachon": "Kichik ma'lumot"},
    {"Turi": "Stochastic GD (SGD)", "Har qadamda": "BITTA qator", "Tezlik": "Tez",
     "Yo'li": "Juda shovqinli", "Qachon": "Juda katta ma'lumot, onlayn o'qitish"},
    {"Turi": "Mini-batch GD", "Har qadamda": "32-256 qator", "Tezlik": "Tez",
     "Yo'li": "O'rtacha shovqinli", "Qachon": "AMALDA ENG KO'P ishlatiladi"},
]))

def mini_batch_gd(X, y, alpha=0.1, epoxalar=30, paket=64, seed=42):
    r = np.random.default_rng(seed)
    w, b = np.zeros(X.shape[1]), 0.0
    tarix = []
    n = len(y)
    for e in range(epoxalar):
        tartib = r.permutation(n)
        for boshi in range(0, n, paket):
            idx = tartib[boshi:boshi + paket]
            dw, db = gradient(X[idx], y[idx], w, b)
            w, b = w - alpha * dw, b - alpha * db
        tarix.append(mse(X, y, w, b))
    return w, b, tarix

w_mb, b_mb, tar_mb = mini_batch_gd(X4, y)
print(f"Batch GD      (1500 qadam): MSE = {tr4.mse.iloc[-1]:>10,.0f}".replace(",", " "))
print(f"Mini-batch GD (30 epoxa)  : MSE = {tar_mb[-1]:>10,.0f}".replace(",", " "))
print(f"sklearn                   : MSE = {mse(X4, y, lr4.coef_, lr4.intercept_):>10,.0f}".replace(",", " "))

show(pd.DataFrame([
    {"Qayerda": "Linear regression (14-bob)", "Gradient descent roli": "Vaznlarni topadi"},
    {"Qayerda": "Logistic regression (15-bob)", "Gradient descent roli": "Xuddi shu, boshqa cost funksiya bilan"},
    {"Qayerda": "Ridge / Lasso (16-bob)", "Gradient descent roli": "Cost ga jarima qo'shiladi"},
    {"Qayerda": "Neyron tarmoq (30-bob)", "Gradient descent roli": "Backpropagation — bu zanjir bo'yicha gradient"},
    {"Qayerda": "XGBoost (19-bob)", "Gradient descent roli": "Nomidan ko'rinadi: Gradient Boosting"},
]))

show(pd.DataFrame([
    {"Tushuncha": "Cost funksiya", "Bitta jumla": "Xatoni bitta son bilan o'lchaydi (MSE)"},
    {"Tushuncha": "Nega kvadrat", "Bitta jumla": "Ishorani yo'qotadi, katta xatoni jazolaydi, hosilasi oson"},
    {"Tushuncha": "Cost — kosa", "Bitta jumla": "Vazifa: kosaning tubini topish"},
    {"Tushuncha": "Gradient", "Bitta jumla": "Qiyalik: belgisi yo'nalishni, kattaligi tiklikni aytadi"},
    {"Tushuncha": "GD qoidasi", "Bitta jumla": "w := w - alpha * gradient"},
    {"Tushuncha": "Learning rate", "Bitta jumla": "Kichik - sekin, katta - portlaydi; oraliq tor"},
    {"Tushuncha": "Nega scaling kerak", "Bitta jumla": "Kosani dumaloq qiladi, bitta alpha hammasiga yetadi"},
    {"Tushuncha": "Mini-batch", "Bitta jumla": "Amalda eng ko'p ishlatiladigan variant"},
]))