Data Science va sun'iy intellekt/Chiziqli algebra6/10-dars18 daqiqa

Mundarija (22)

10.6-dars: Eng kichik kvadratlar

10-QISM — CHIZIQLI ALGEBRA · 6-dars

1. Kirish va motivatsiya

10.5-darsda ko'rdik: Data Science'da sistema odatda n > p — 1000 ta uy (tenglama), 3 ta belgi (noma'lum). Shovqin tufayli X @ w = y ni aniq qanoatlantiruvchi w yo'q. Unda qanday w "eng yaxshi"? Javob — eng kichik kvadratlar (least squares): xatolar kvadratlari yig'indisini, ||y - X @ w||^2 ni minimal qiladigan w. Bu — chiziqli regressiyaning o'zi, 200 yildan beri statistikaning ustuni (Gauss, Legendre).

Bu darsda regressiyani chiziqli algebra tilida qayta ko'ramiz, va u juda chiroyli ma'no oladi: bashorat y_hat — y ning belgilar fazosiga proyeksiyasi 10.2-bob, qoldiq — shu fazoga ortogonal. Bundan normal tenglama kelib chiqadi: X.T @ X @ w = X.T @ y. Amalda uni np.linalg.lstsq (SVD asosida, barqaror) yechadi. Ridge regularizatsiyasi esa matritsa tilida bitta qo'shimcha: X.T X + alpha I — deyarli singulyar sistemani 10.5-bob barqaror qiladi.

Real vaziyat. Tahlilchi LinearRegression ni "qora quti" sifatida ishlatadi. Bir kuni 60 kuzatuv, 80 belgi (p > n) bilan model o'qitadi: o'quv R^2 = 1.00 — mukammal! Test R^2 = 0.27 — model shovqinni yodlagan. Chiziqli algebra tushuntiradi: p > n da X.T X singulyar — cheksiz ko'p w aniq mos keladi (shovqinni ham yodlaydi). Ridge (X.T X + alpha I) — yagona, barqaror yechim tanlaydi; test R^2 0.40 gacha ko'tarildi (ma'lumot kam — mo'jiza yo'q, lekin yaxshilanish aniq). Normal tenglamani bilish — overfitting sababini ko'rsatdi.

Bu darsda eng kichik kvadratlarni o'rganamiz.

Bu darsda:

Eng kichik kvadratlar masalasi
Normal tenglama: X.T X w = X.T y
Geometriya: proyeksiya va ortogonal qoldiq
np.linalg.lstsq va sklearn
Intercept (kesishish) ustuni
Ridge: X.T X + alpha I
Eng kichik kvadratlar tuzoqlari
Amaliy: regressiyani qo'lda qurish

ℹ Misollar real numpy/sklearn bilan (Python 3.14).

2. Nazariya — chuqur tushuntirish

2.1. Eng kichik kvadratlar masalasi

text

Model:       y ≈ X @ w          X: n × p (n > p), y: n
Qoldiq:      r = y - X @ w      har kuzatuv xatosi
Maqsad:      min ||r||^2 = min sum( (yi - xi · w)^2 )    ← "kvadratlar yig'indisi" (SSE)

Nega kvadrat?
  - musbat va manfiy xatolar bir-birini "yo'q qilmaydi"
  - katta xato qattiqroq jazolanadi
  - silliq funksiya → yopiq formula (normal tenglama)
  - xato normal taqsimotli bo'lsa — MLE (9.9)

Eng kichik kvadratlar — aniq yechim yo'q bo'lganda "eng yaxshi" yechim: qoldiqlar kvadratlari yig'indisini (SSE, MSE × n) minimallashtirish. Kvadrat tanlovi — tasodif emas: xato normal taqsimotli bo'lsa, bu maksimal ishonchlilik 9.9-bob; matematik jihatdan qulay (yopiq formula). Kamchiligi: outlierlarga sezgir (kvadrat — katta xatoni kuchaytiradi) — shuning uchun ba'zan L1 (Huber, median regressiya) ishlatiladi.

2.2. Normal tenglama

text

Minimum shartida qoldiq X ning barcha ustunlariga ORTOGONAL:
  X.T @ (y - X @ w) = 0
→ X.T @ X @ w = X.T @ y                ← NORMAL TENGLAMA (p × p sistema)
→ w = (X.T @ X)^(-1) @ X.T @ y         ← formulada; amalda solve/lstsq

X.T @ X — p × p (kichik!), X.T @ y — p
Yagona yechim sharti: X to'liq rank (ustunlar mustaqil, 10.5)

Normal tenglama — n × p "yechib bo'lmaydigan" sistemani p × p yechiladigan sistemaga aylantiradi. Kelib chiqishi geometrik: eng yaxshi w da qoldiq belgilarning hech biri bilan bog'liq bo'lmasligi kerak (aks holda o'sha belgi bo'ylab yana yaxshilash mumkin edi) — ya'ni X.T r = 0. X.T X — 10.3 dagi "belgilar orasidagi skalyar ko'paytmalar" matritsasi (markazlashtirilganda — kovariatsiya). Singulyar bo'lsa (multikollinearlik, p > n) — yagona yechim yo'q.

2.3. Geometriya: proyeksiya va ortogonal qoldiq

text

y — n o'lchamli fazodagi vektor
X ustunlari — shu fazoda p o'lchamli "tekislik" (ustunlar fazosi) hosil qiladi

y_hat = X @ w   — y ning shu tekislikka PROYEKSIYASI (eng yaqin nuqta)
r = y - y_hat   — tekislikka PERPENDIKULYAR qoldiq

||y||^2 = ||y_hat||^2 + ||r||^2   (markazlashtirilganda: SST = SSR + SSE)
R^2 = 1 - SSE / SST   — y dispersiyasining proyeksiya "tushuntirgan" ulushi

Regressiya — proyeksiya (10.2 ning n o'lchamli ko'rinishi): y_hat — belgilar kombinatsiyalari orasida y ga eng yaqin vektor; qoldiq — ortogonal. Oqibatlari: qoldiqlar yig'indisi 0 (intercept bo'lsa — birlar ustuniga ortogonal); qoldiq bashoratga korrelyatsiyasiz; Pifagor — SST = SSR + SSE → R^2 (4.9, 8.5). Belgi qo'shsangiz tekislik kengayadi — SSE hech qachon oshmaydi, R^2 hech qachon tushmaydi (o'quvda) — shuning uchun o'quv R^2 overfittingni ko'rsatmaydi.

2.4. np.linalg.lstsq va sklearn

Amalda: w, *_ = np.linalg.lstsq(X, y, rcond=None) — SVD 10.8-bob asosida: normal tenglamani to'g'ridan-to'g'ri yechishdan barqarorroq (X.T X ni hisoblash shart sonini kvadratga oshiradi: cond(X.T X) = cond(X)^2); rank yetishmasa ham eng kichik normali yechimni qaytaradi. sklearn.linear_model.LinearRegression — ichida xuddi shunday (scipy lstsq). Qoidalar: yechish uchun inv(X.T @ X) ishlatmang; kichik va yaxshi masalalarda solve(X.T @ X, X.T @ y) ham ishlaydi; umumiy holatda — lstsq yoki sklearn.

2.5. Intercept (kesishish) ustuni

text

y ≈ w0 + w1 x1 + ... + wp xp

X_1 = [1, x1, x2, ..., xp]   — birlar ustuni qo'shiladi
w = [w0, w1, ..., wp]          — w0 — intercept

np.column_stack([np.ones(n), X])
sklearn: fit_intercept=True (standart) — o'zi qo'shadi

Intercept — "barcha belgilar 0 bo'lganda" bashorat; matritsa tilida — birlar ustuni (doimiy belgi). Qo'lda regressiyada uni unutish — model majburan boshlanishdan o'tadi (noto'g'ri qiyalik). Intercept bor bo'lsa, one-hot'ning bitta ustunini tashlash kerak (dummy tuzog'i, 10.5). Markazlashtirilgan ma'lumotda intercept = y ning o'rtachasi, qolgan koeffitsiyentlar — kovariatsiyalardan.

2.6. Ridge: X.T X + alpha I

text

Ridge maqsadi:   min ||y - X w||^2 + alpha × ||w||^2      (L2 jarima, 10.1)
Yechim:          (X.T X + alpha I) w = X.T y

alpha I diagonalga qo'shiladi →
  - matritsa har doim teskarilanadi (singulyar bo'lmaydi, p > n da ham)
  - shart soni kamayadi → barqaror koeffitsiyentlar
  - koeffitsiyentlar 0 ga "qisqaradi" (shrinkage) → kamroq overfitting
alpha = 0 → oddiy eng kichik kvadratlar; alpha → cheksiz → w → 0

Ridge — chiziqli algebra nuqtai nazaridan eng oddiy "tuzatish": diagonalga alpha qo'shish. Natija: (1) har doim yechim bor (p > n, multikollinearlik); (2) barqarorlik (10.5 dagi beqaror koeffitsiyentlar tinchlanadi); (3) overfitting kamayadi (murakkablik jarimasi). Narxi: biroz siljish (bias) — koeffitsiyentlar haqiqiydan kichikroq. alpha — giperparametr (cross-validation bilan tanlanadi). Muhim: Ridge'dan oldin standartlashtirish — aks holda jarima birliklarga bog'liq 10.1-bob.

2.7. Eng kichik kvadratlar tuzoqlari

Asosiy tuzoqlar: inv(X.T X) bilan yechish (beqaror — lstsq); intercept'ni unutish (qo'lda regressiyada); dummy tuzog'i (birlar ustuni + barcha one-hot); p > n da oddiy regressiya (o'quvda mukammal, testda halokat — Ridge); o'quv R^2 ga ishonish (belgi qo'shsa doim o'sadi — test yoki adjusted R^2); outlierlar (kvadrat — bitta nuqta chiziqni tortadi; qoldiqlarni ko'ring); masshtabsiz Ridge (jarima birliklarga bog'liq); nochiziqli bog'lanish (chiziqli model — to'g'ri chiziq; polinom belgilar yoki boshqa model); y va X qatorlari tartibi (pandas indeks — to_numpy dan oldin moslang).

2.8. Eng kichik kvadratlar — regressiyaning chiziqli algebrasi

Eng kichik kvadratlar: n > p sistemada min ||y - Xw||^2; normal tenglama X.T X w = X.T y (qoldiq ustunlarga ortogonal); geometriya — y_hat = y ning ustunlar fazosiga proyeksiyasi, SST = SSR + SSE, R^2; amalda — lstsq / LinearRegression (SVD, barqaror; inv emas); intercept — birlar ustuni; Ridge — (X.T X + alpha I): har doim yechim, barqarorlik, kamroq overfitting (standartlashtirish bilan). Keyingi dars — xos qiymatlar va xos vektorlar: matritsa "o'zgartirmaydigan" yo'nalishlar.

3. Tez ma'lumotnoma

python

import numpy as np
from sklearn.linear_model import LinearRegression, Ridge

X1 = np.column_stack([np.ones(len(X)), X])        # intercept ustuni

w = np.linalg.solve(X1.T @ X1, X1.T @ y)          # normal tenglama (kichik, yaxshi masala)
w, *_ = np.linalg.lstsq(X1, y, rcond=None)        # barqaror (SVD)

y_hat = X1 @ w
r = y - y_hat
X1.T @ r                                          # ≈ 0 (ortogonallik)
R2 = 1 - (r @ r) / ((y - y.mean()) @ (y - y.mean()))

# Ridge qo'lda (intercept jarimalanmaydi — markazlashtirilgan ma'lumotda)
Xc, yc = X - X.mean(0), y - y.mean()
w_r = np.linalg.solve(Xc.T @ Xc + alpha * np.eye(p), Xc.T @ yc)

LinearRegression().fit(X, y); Ridge(alpha=1.0).fit(X, y)
QOIDA: lstsq > solve > inv · birlar ustuni · p > n → Ridge · Ridge oldidan standartlashtir

Eng kichik kvadratlar xulosasi

min ||y - X w||^2 — aniq yechim yo'q bo'lganda eng yaxshi
Normal tenglama: X.T X w = X.T y (qoldiq ustunlarga ortogonal)
y_hat — y ning ustunlar fazosiga proyeksiyasi; SST = SSR + SSE
lstsq — barqaror (cond(X.T X) = cond(X)^2)
Intercept — birlar ustuni
Ridge: (X.T X + alpha I) w = X.T y — barqaror, kam overfitting

4. Batafsil misollar

Misollar real numpy/sklearn bilan (Python 3.14).

Misol 1 — Normal tenglama va sklearn

python

"""Regressiya qo'lda: normal tenglama, lstsq va sklearn natijasi bir xil (real numpy/sklearn)."""

import numpy as np
from sklearn.linear_model import LinearRegression


def main() -> None:
    rng = np.random.default_rng(0)
    n = 300
    maydon = rng.normal(70, 20, n)
    xona = rng.integers(1, 5, n).astype(float)
    narx = 20 + 1.5 * maydon + 8 * xona + rng.normal(0, 10, n)
    X = np.column_stack([maydon, xona])

    print("=== 1. Intercept ustuni ===")
    X1 = np.column_stack([np.ones(n), X])
    print(f"  X1 shakli: {X1.shape}, birinchi qator: {np.round(X1[0], 1)}")

    print("\n=== 2. Uch usul ===")
    w_normal = np.linalg.solve(X1.T @ X1, X1.T @ narx)
    w_lstsq, *_ = np.linalg.lstsq(X1, narx, rcond=None)
    m = LinearRegression().fit(X, narx)
    w_sk = np.r_[m.intercept_, m.coef_]
    for nom, w in [("normal tenglama", w_normal), ("lstsq", w_lstsq), ("sklearn", w_sk)]:
        print(f"  {nom:<16}: {np.round(w, 3)}")

    print("\n=== 3. Interceptsiz (xato) ===")
    w_yoq, *_ = np.linalg.lstsq(X, narx, rcond=None)
    print(f"  koeffitsiyentlar: {np.round(w_yoq, 3)}  ← siljigan")
    print("  ⭐ Haqiqiy: 20, 1.5, 8")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Intercept ustuni ===
  X1 shakli: (300, 3), birinchi qator: [ 1.  72.5  1. ]

=== 2. Uch usul ===
  normal tenglama : [22.832  1.466  7.608]
  lstsq           : [22.832  1.466  7.608]
  sklearn         : [22.832  1.466  7.608]

=== 3. Interceptsiz (xato) ===
  koeffitsiyentlar: [ 1.678 10.346]  ← siljigan
  ⭐ Haqiqiy: 20, 1.5, 8

Nima ko'rsatdi: 2.2, 2.4, 2.5-bo'limlar.

Misol 2 — Proyeksiya: ortogonal qoldiq va R^2

python

"""Regressiya — proyeksiya: X.T @ r = 0, SST = SSR + SSE (real numpy)."""

import numpy as np


def main() -> None:
    rng = np.random.default_rng(1)
    n = 200
    x = rng.normal(0, 1, n)
    y = 3 + 2 * x + rng.normal(0, 1.5, n)
    X1 = np.column_stack([np.ones(n), x])

    w, *_ = np.linalg.lstsq(X1, y, rcond=None)
    y_hat = X1 @ w
    r = y - y_hat

    print("=== 1. Qoldiq ustunlarga ortogonal ===")
    print(f"  X1.T @ r = {np.round(X1.T @ r, 10)}")
    print(f"  qoldiqlar yig'indisi: {r.sum():.2e}")
    print(f"  corr(y_hat, r) = {np.corrcoef(y_hat, r)[0, 1]:.2e}")

    print("\n=== 2. Pifagor: SST = SSR + SSE ===")
    SST = ((y - y.mean()) ** 2).sum()
    SSR = ((y_hat - y.mean()) ** 2).sum()
    SSE = (r ** 2).sum()
    print(f"  {SST:.1f} = {SSR:.1f} + {SSE:.1f}")
    print(f"  R^2 = 1 - SSE/SST = {1 - SSE / SST:.4f}")

    print("\n=== 3. Tasodifiy belgi qo'shsak — o'quv R^2 ===")
    for k in [0, 5, 20, 50]:
        Xk = np.column_stack([X1, rng.normal(size=(n, k))]) if k else X1
        wk, *_ = np.linalg.lstsq(Xk, y, rcond=None)
        rk = y - Xk @ wk
        print(f"  +{k:>2} shovqin belgi: R^2 = {1 - (rk @ rk) / SST:.4f}")
    print("  ⭐ O'quv R^2 hech qachon tushmaydi — overfittingni ko'rsatmaydi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Qoldiq ustunlarga ortogonal ===
  X1.T @ r = [-0. -0.]
  qoldiqlar yig'indisi: -2.13e-13
  corr(y_hat, r) = -3.75e-16

=== 2. Pifagor: SST = SSR + SSE ===
  1085.3 = 725.1 + 360.1
  R^2 = 1 - SSE/SST = 0.6681

=== 3. Tasodifiy belgi qo'shsak — o'quv R^2 ===
  + 0 shovqin belgi: R^2 = 0.6681
  + 5 shovqin belgi: R^2 = 0.6721
  +20 shovqin belgi: R^2 = 0.7039
  +50 shovqin belgi: R^2 = 0.7835
  ⭐ O'quv R^2 hech qachon tushmaydi — overfittingni ko'rsatmaydi

Nima ko'rsatdi: 2.3, 2.7-bo'limlar.

Misol 3 — Barqarorlik: lstsq va normal tenglama

python

"""cond(X.T X) = cond(X)^2: nega lstsq barqarorroq (real numpy)."""

import numpy as np


def main() -> None:
    rng = np.random.default_rng(2)
    n = 500
    x = rng.uniform(0, 1, n)
    # 14 ta polinom belgi (1, x, x^2, ...) — kuchli bog'liq ustunlar
    X = np.column_stack([x ** k for k in range(14)])
    y = X @ rng.normal(0, 1, 14) + rng.normal(0, 1e-10, n)   # deyarli shovqinsiz

    print("=== 1. Shart sonlari ===")
    print(f"  cond(X)       = {np.linalg.cond(X):.1e}")
    print(f"  cond(X.T @ X) = {np.linalg.cond(X.T @ X):.1e}  (≈ cond(X)^2)")

    print("\n=== 2. Qoldiq xatosi (RMSE; shovqin 1e-10) ===")
    w_n = np.linalg.solve(X.T @ X, X.T @ y)
    w_l, *_ = np.linalg.lstsq(X, y, rcond=None)
    for nom, w in [("normal tenglama", w_n), ("lstsq", w_l)]:
        rmse = np.sqrt(np.mean((y - X @ w) ** 2))
        print(f"  {nom:<16}: RMSE = {rmse:.1e}")

    print("\n=== 3. Standartlashtirish bu yerda yetarli emas (ustunlar bog'liq) ===")
    Xs = (X[:, 1:] - X[:, 1:].mean(0)) / X[:, 1:].std(0)
    print(f"  cond(standartlashtirilgan) = {np.linalg.cond(Xs):.1e}")
    print("  ⭐ lstsq (SVD) — normal tenglamadan barqaror; bog'liqlikni Ridge davolaydi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Shart sonlari ===
  cond(X)       = 4.7e+09
  cond(X.T @ X) = 3.5e+18  (≈ cond(X)^2)

=== 2. Qoldiq xatosi (RMSE; shovqin 1e-10) ===
  normal tenglama : RMSE = 1.2e-07
  lstsq           : RMSE = 1.0e-10

=== 3. Standartlashtirish bu yerda yetarli emas (ustunlar bog'liq) ===
  cond(standartlashtirilgan) = 2.4e+09
  ⭐ lstsq (SVD) — normal tenglamadan barqaror; bog'liqlikni Ridge davolaydi

Nima ko'rsatdi: 2.4, 2.7-bo'limlar.

Misol 4 — p > n: oddiy regressiya va Ridge

python

"""p > n: X.T X singulyar, overfitting; Ridge (X.T X + alpha I) (real numpy/sklearn)."""

import numpy as np
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.metrics import r2_score
from sklearn.preprocessing import StandardScaler


def main() -> None:
    rng = np.random.default_rng(3)
    n, p = 60, 80
    X = rng.normal(size=(2 * n, p))
    w = np.zeros(p); w[:5] = [3, -2, 1.5, 1, -1]
    y = X @ w + rng.normal(0, 1, 2 * n)
    Xtr, Xte, ytr, yte = X[:n], X[n:], y[:n], y[n:]

    print("=== 1. X.T X ranki ===")
    print(f"  n = {n}, p = {p}, rank(X.T X) = {np.linalg.matrix_rank(Xtr.T @ Xtr)}")

    print("\n=== 2. Oddiy regressiya vs Ridge ===")
    sc = StandardScaler().fit(Xtr)
    Xtr_s, Xte_s = sc.transform(Xtr), sc.transform(Xte)
    for nom, m in [("LinearRegression", LinearRegression()),
                   ("Ridge alpha=1", Ridge(alpha=1.0)),
                   ("Ridge alpha=10", Ridge(alpha=10.0))]:
        m.fit(Xtr_s, ytr)
        print(f"  {nom:<16}: o'quv R^2 {r2_score(ytr, m.predict(Xtr_s)):.3f}, "
              f"test R^2 {r2_score(yte, m.predict(Xte_s)):.3f}")

    print("\n=== 3. Ridge qo'lda = sklearn ===")
    Xc, yc = Xtr_s - Xtr_s.mean(0), ytr - ytr.mean()
    w_r = np.linalg.solve(Xc.T @ Xc + 10.0 * np.eye(p), Xc.T @ yc)
    print(f"  bir xil: {np.allclose(w_r, Ridge(alpha=10.0).fit(Xtr_s, ytr).coef_)}")
    print("  ⭐ alpha I — singulyarlikni yo'qotadi, overfittingni kamaytiradi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. X.T X ranki ===
  n = 60, p = 80, rank(X.T X) = 60

=== 2. Oddiy regressiya vs Ridge ===
  LinearRegression: o'quv R^2 1.000, test R^2 0.274
  Ridge alpha=1   : o'quv R^2 1.000, test R^2 0.311
  Ridge alpha=10  : o'quv R^2 0.985, test R^2 0.395

=== 3. Ridge qo'lda = sklearn ===
  bir xil: True
  ⭐ alpha I — singulyarlikni yo'qotadi, overfittingni kamaytiradi

Nima ko'rsatdi: 2.6, 2.7-bo'limlar.

5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr	To'g'risi
"Regressiya — statistik sehr"	Proyeksiya (chiziqli algebra)
"w = inv(X.T X) X.T y — amalda shunday"	lstsq (barqaror)
"O'quv R^2 yuqori — yaxshi model"	Belgi qo'shsa doim o'sadi
"p > n da ham oddiy regressiya"	Cheksiz yechim — Ridge
"Qoldiqlar belgilar bilan bog'liq bo'lishi mumkin"	Ortogonal (qurilishiga ko'ra)
"Intercept avtomatik"	Qo'lda — birlar ustuni
"Ridge — boshqa algoritm"	Diagonalga alpha qo'shish
"Masshtab Ridge'ga ta'sir qilmaydi"	Jarima birlikka bog'liq

6. Keng tarqalgan xatolar va yechimlari

1. inv bilan

python

w = np.linalg.inv(X.T @ X) @ X.T @ y                              # ⚠️
w, *_ = np.linalg.lstsq(X, y, rcond=None)                         # ✅

2. Intercept yo'q

python

w, *_ = np.linalg.lstsq(X, y, rcond=None)                         # ⚠️
w, *_ = np.linalg.lstsq(np.column_stack([np.ones(len(X)), X]), y, rcond=None)  # ✅

3. p > n oddiy regressiya

python

LinearRegression().fit(X_60x80, y)     # o'quvda mukammal         # ⚠️
Ridge(alpha=1.0).fit(StandardScaler().fit_transform(X), y)        # ✅

4. O'quv R^2 bilan tanlash

python

print(model.score(X_train, y_train))                              # ⚠️
print(model.score(X_test, y_test))                                # ✅

5. Masshtabsiz Ridge

python

Ridge(alpha=1).fit(X_xom, y)          # so'm va m2 aralash         # ⚠️
make_pipeline(StandardScaler(), Ridge(alpha=1)).fit(X, y)          # ✅

6. rcond ogohlantirishi

python

np.linalg.lstsq(X, y)                  # FutureWarning (eski)      # ⚠️
np.linalg.lstsq(X, y, rcond=None)                                 # ✅

7. Indeks moslashmagan

python

X = df1[["a", "b"]].to_numpy(); y = df2["y"].to_numpy()  # tartib? # ⚠️
d = df1.join(df2["y"]); X, y = d[["a", "b"]].to_numpy(), d["y"].to_numpy()  # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

10.2-dars (o'tilgan): Proyeksiya, ortogonallik
10.5-dars (o'tilgan): Rank, shart soni, multikollinearlik
8.5, 4.9-darslar (o'tilgan): Korrelyatsiya, R^2
10.8-dars: SVD (lstsq ichida)
Regressiya qismi: Ridge, Lasso, polinom, baholash

8. Eng yaxshi amaliyotlar

Regressiyani proyeksiya sifatida tushuning.
Yechish — lstsq yoki sklearn.
Qo'lda — birlar ustunini qo'shing.
Qoldiqlar ortogonalligini tekshiring (X.T r ≈ 0).
Baholash — test to'plamida.
p ≥ n yoki multikollinearlik — Ridge.
Ridge'dan oldin standartlashtiring.
Qoldiqlarni grafikda ko'ring (outlier, nochiziqlilik).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python

1.  # eng kichik kvadratlar nimani minimallashtiradi?
2.  # normal tenglama?
3.  # X.T X shakli (X: 1000 × 5)?
4.  # X.T @ r = ?
5.  # intercept bo'lsa qoldiqlar yig'indisi?
6.  # SST = ?
7.  # belgi qo'shsa o'quv R^2?
8.  # cond(X.T X) = ?
9.  # p > n da X.T X?
10. # Ridge formulasi?
11. # alpha → cheksiz bo'lsa w?
12. # Ridge'dan oldin nima?

Javoblar

||y - Xw||^2 (qoldiq kvadratlari yig'indisi)
X.T X w = X.T y
5 × 5
0
0
SSR + SSE
Tushmaydi
cond(X)^2
Singulyar
(X.T X + alpha I) w = X.T y
0 ga
Standartlashtirish

Vazifa 2: Xatolarni tuzating

python

1.  w = np.linalg.inv(X.T @ X) @ X.T @ y

2.  w, *_ = np.linalg.lstsq(X, y, rcond=None)   # intercept kerak

3.  LinearRegression().fit(X, y)   # X: 50 × 200

4.  print("R^2:", model.score(X_train, y_train))   # model tanlash

5.  Ridge(alpha=5).fit(df[["maydon", "narx_som"]], y)

Javoblar

python

1.  w, *_ = np.linalg.lstsq(X, y, rcond=None)

2.  w, *_ = np.linalg.lstsq(np.column_stack([np.ones(len(X)), X]), y, rcond=None)

3.  make_pipeline(StandardScaler(), Ridge(alpha=1.0)).fit(X, y)

4.  print("R^2:", model.score(X_test, y_test))

5.  make_pipeline(StandardScaler(), Ridge(alpha=5)).fit(df[["maydon", "narx_som"]], y)

Vazifa 3: Qo'lda regressiya

Modellang:

Uy ma'lumoti (3 belgi)
Normal tenglama va lstsq
LinearRegression bilan solishtirish
Qoldiq ortogonalligi

Vazifa 4: R^2 va overfitting

Modellang:

100 kuzatuv
0..90 tasodifiy belgi qo'shish
O'quv va test R^2 grafigi
Xulosa

Vazifa 5: Ridge yo'li

Modellang:

Multikollinear ma'lumot
alpha = 0.01..1000
Koeffitsiyentlar yo'li (grafik)
Test xatosi minimumi

Vazifa 6: Integratsiya

Modellang:

Proyeksiya (10.2)
Rank va cond (10.5)
Standartlashtirish (6.6)
R^2 (4.9)

Vazifa 7: O'ylash

Eng kichik kvadratlar 200 yildan ortiq vaqt davomida ishlatiladi va hali ham Data Science'ning asosiy vositalaridan biri — ko'pincha murakkab ML modellarining "baza" (baseline) modeli. Nima uchun oddiy chiziqli regressiya hali ham bunchalik muhim? Uning geometrik (proyeksiya) talqini qanday afzalliklar va cheklovlarni ochib beradi?

Javob

Qisqa javob: chiziqli regressiya — tez, tushunarli, yopiq formulali va nazariy jihatdan yaxshi o'rganilgan. Proyeksiya talqini uning nima qilishini aniq ko'rsatadi: y ni belgilar kombinatsiyalari orasidagi eng yaqin nuqtaga "tushiradi". Bu ham kuchi (optimal, barqaror, talqin qilinadi), ham cheklovi (faqat belgilar fazosidagi narsani ko'radi — nochiziqlilikni emas).

1. Nega hali ham muhim

Tez: millionlab qatorda soniyalar
Talqin: har koeffitsiyent — "boshqalar o'zgarmasa, ta'sir"
Baza model: murakkab model undan yaxshiroq bo'lishi shart
Ko'p murakkab usullar ichida: neyron tarmoqning oxirgi qatlami, GLM, Ridge/Lasso

2. Proyeksiya ochib beradigan afzalliklar

Xossa	Ma'nosi
Eng yaqin nuqta	Berilgan belgilar bilan eng yaxshi chiziqli bashorat
Qoldiq ortogonal	Belgilarda qolgan chiziqli ma'lumot yo'q
SST = SSR + SSE	R^2 — aniq dispersiya ulushi
Yopiq formula	Iteratsiyasiz, takrorlanadigan natija

3. Cheklovlar

Faqat ustunlar fazosi: nochiziqli bog'lanish — belgi muhandisligi kerak (polinom, log)
Kvadrat — outlierga sezgir
p katta/multikollinear — beqaror (Ridge kerak)
Proyeksiya korrelyatsiyani ko'radi, sababiylikni emas

4. Data Scientist qanday

Har loyihada chiziqli baza modeldan boshlaydi
Qoldiqlarni tahlil qilib, nimani o'tkazib yuborganini ko'radi
Belgilarni boyitadi (o'zgartirish, o'zaro ta'sir)
Murakkab model faqat bazadan sezilarli yaxshi bo'lsa tanlanadi

5. Xulosa

Chiziqli regressiya — proyeksiya: optimal, tez, tushunarli
Ortogonal qoldiq — model chegarasini ko'rsatadi
Cheklovlar — belgilar va regularizatsiya bilan yengiladi
Baza model — har qanday murakkab modelning o'lchovi

Nimani mustahkamlaydi: 2.3, 2.6-bo'limlar.

Xulosa

Bu darsda eng kichik kvadratlarni o'rgandik.

Eng muhim uch fikr:

Masala va normal tenglama. n > p sistemada aniq yechim yo'q → min ||y - X w||^2. Minimumda qoldiq barcha ustunlarga ortogonal: X.T X w = X.T y (p × p sistema). Intercept — birlar ustuni; yagona yechim uchun X to'liq rank.
Regressiya — proyeksiya. y_hat — y ning ustunlar fazosiga proyeksiyasi; qoldiq ortogonal (yig'indisi 0, bashoratga korrelyatsiyasiz); SST = SSR + SSE → R^2. Belgi qo'shsa o'quv R^2 hech qachon tushmaydi — baholash testda. Amalda lstsq/sklearn (SVD; cond(X.T X) = cond(X)^2 — normal tenglama beqarorroq), inv hech qachon.
Ridge. (X.T X + alpha I) w = X.T y — diagonalga alpha: p > n va multikollinearlikda ham yagona, barqaror yechim; koeffitsiyentlar qisqaradi, overfitting kamayadi. Oldin standartlashtirish; alpha — cross-validation bilan.

Keyingi darsda xos qiymatlar va xos vektorlarni o'rganamiz: matritsa faqat cho'zadigan (yo'nalishini o'zgartirmaydigan) vektorlar, simmetrik matritsalar, kovariatsiya matritsasining xos vektorlari va Markov zanjirining barqaror holati.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!