Vektor va matritsa — ma'lumotning tili

import pandas as pd
import numpy as np

df = pd.read_csv(DATA / "uy_ijara.csv")
son = ["xonalar", "maydon_m2", "metro_km", "mebel"]

bitta = df.loc[0, son]
print("Bitta kvartira (bitta qator):")
print(bitta.to_string())
print()
x = bitta.to_numpy(dtype=float)
print("numpy vektori:", x)
print("shakli (shape):", x.shape, " -> 4 ta son")

X = df[son].to_numpy(dtype=float)
print("Butun jadval:")
print(f"  shakli: {X.shape}  ->  {X.shape[0]} qator (namuna), {X.shape[1]} ustun (xususiyat)")
print()
print("Birinchi 3 qator:")
print(X[:3])
print()
print("Matritsadan element olish:")
print(f"  X[0, 1] = {X[0, 1]}      -> 1-qator, 2-ustun (birinchi kvartiraning maydoni)")
print(f"  X[0]    = {X[0]}  -> butun 1-qator (bitta kvartira)")
print(f"  X[:, 1][:5] = {X[:, 1][:5]}  -> 2-ustunning birinchi 5 qiymati (maydonlar)")

# vaznlar: har bir xususiyat narxga qancha ta'sir qiladi
w = np.array([55.0, 7.5, -28.0, 90.0])
b = 180.0            # bias (boshlang'ich qiymat)

print("Vaznlar va ularning ma'nosi:")
for nom, vazn in zip(son, w):
    print(f"  {nom:12s} {vazn:>7.1f}")
print(f"  {'bias':12s} {b:>7.1f}")
print()
print("Bitta kvartira uchun bashorat — QO'LDA:")
qadamlar = [f"{x[i]:.2f} x {w[i]:.1f}" for i in range(len(w))]
print("  " + " + ".join(qadamlar) + f" + {b:.0f}")
bashorat_qolda = sum(x[i] * w[i] for i in range(len(w))) + b
print(f"  = {bashorat_qolda:.2f}")

bashorat_dot = x @ w + b          # @ — skalyar ko'paytma belgisi
print(f"x @ w + b = {bashorat_dot:.2f}")
print(f"Qo'lda hisoblangan: {bashorat_qolda:.2f}")
print(f"Bir xilmi: {np.isclose(bashorat_dot, bashorat_qolda)}")

import time

# 1-yo'l: sikl bilan
t0 = time.perf_counter()
bashoratlar_sikl = []
for i in range(len(X)):
    s = 0.0
    for j in range(X.shape[1]):
        s += X[i, j] * w[j]
    bashoratlar_sikl.append(s + b)
sikl_vaqti = time.perf_counter() - t0
bashoratlar_sikl = np.array(bashoratlar_sikl)

# 2-yo'l: matritsa ko'paytirish
t0 = time.perf_counter()
bashoratlar_vek = X @ w + b
vek_vaqti = time.perf_counter() - t0

print(f"Sikl bilan    : {sikl_vaqti*1000:.2f} ms")
print(f"X @ w bilan   : {vek_vaqti*1000:.4f} ms")
print(f"Natijalar bir xilmi: {np.allclose(bashoratlar_sikl, bashoratlar_vek)}")
print(f"Tezlik farqi  : {sikl_vaqti/max(vek_vaqti, 1e-9):.0f} barobar")

print(f"X shakli      : {X.shape}")
print(f"w shakli      : {w.shape}")
print(f"X @ w shakli  : {(X @ w).shape}   -> har bir qator uchun bitta son")
print()
print("Birinchi 5 bashorat:", (X @ w + b)[:5].round(1))
print("Haqiqiy narxlar   :", df.narx_usd.head(5).to_numpy())

A = np.array([[1., 2., 3.], [4., 5., 6.]])        # 2x3
B = np.array([[1., 0.], [0., 1.], [1., 1.]])      # 3x2
print(f"A shakli: {A.shape}")
print(f"B shakli: {B.shape}")
print(f"A @ B    : {(A @ B).shape}   <- 3 va 3 MOS keldi, natija 2x2")
print(A @ B)
print()
try:
    B @ A @ B @ A
except ValueError as e:
    pass
try:
    _ = A @ A
except ValueError as e:
    print("A @ A xato beradi:", str(e)[:62])
print()
print("QOIDA: (n x m) @ (m x k) = (n x k).  O'rtadagi ikki son MOS kelishi shart.")

print(f"X shakli   : {X.shape}")
print(f"X.T shakli : {X.T.shape}   <- qator va ustun almashdi")
print()
print("Nega kerak: ustunlar o'zaro bog'liqligini hisoblash uchun")
Xm = X - X.mean(axis=0)                      # markazlashtirish
kov = (Xm.T @ Xm) / (len(X) - 1)             # kovariatsiya matritsasi
print(f"Xm.T @ Xm shakli: {kov.shape}   <- 4x4, har ustun juftligi uchun bitta son")
print()
print("Korrelyatsiya (kovariatsiyadan normallashtirilgan):")
std = np.sqrt(np.diag(kov))
korr = kov / np.outer(std, std)
print(pd.DataFrame(korr.round(3), index=son, columns=son).to_string())

print("Har bir ustundan uning o'rtachasini ayirish — SIKL KERAK EMAS:")
print(f"  X shakli          : {X.shape}")
print(f"  X.mean(axis=0)    : {X.mean(axis=0).shape}  -> 4 ta son")
markaz = X - X.mean(axis=0)
print(f"  X - mean natijasi : {markaz.shape}  <- numpy 4 ta sonni 1200 qatorga YOYDI")
print()
print(f"  Tekshiruv — yangi o'rtachalar: {markaz.mean(axis=0).round(10)}")
print()
print("Bu — broadcasting. StandardScaler ichida aynan shu bo'ladi:")
shkala = (X - X.mean(axis=0)) / X.std(axis=0)
print(f"  o'rtacha: {shkala.mean(axis=0).round(6)}")
print(f"  std     : {shkala.std(axis=0).round(6)}")

a = np.array([1, 2, 3])
bb = np.array([[1], [2], [3]])
print(f"a shakli      : {a.shape}")
print(f"b shakli      : {bb.shape}")
print(f"a + b shakli  : {(a + bb).shape}   <- 3 ta son kutgandingiz, 9 ta oldingiz")
print(a + bb)

v = np.array([3.0, 4.0])
print(f"v = {v}")
print()
print(f"L2 norma (Evklid)  : {np.linalg.norm(v, 2):.4f}   = sqrt(3^2 + 4^2)")
print(f"L1 norma (Manhattan): {np.linalg.norm(v, 1):.4f}   = |3| + |4|")
print()
print("Bizning vaznlarimiz uchun:")
print(f"  w = {w}")
print(f"  L2 norma: {np.linalg.norm(w, 2):.2f}")
print(f"  L1 norma: {np.linalg.norm(w, 1):.2f}")

show(pd.DataFrame([
    {"Norma": "L2 (kvadratlar yig'indisining ildizi)", "Formula": "sqrt(sum(w^2))",
     "Qayerda ishlatiladi": "Ridge regression — katta vaznni jazolaydi"},
    {"Norma": "L1 (mutlaq qiymatlar yig'indisi)", "Formula": "sum(|w|)",
     "Qayerda ishlatiladi": "Lasso — vaznni AYNAN nolga tushiradi"},
]))

show(pd.DataFrame([
    {"Tushuncha": "Vektor", "Kodda": "x = np.array([...])", "ML da": "Bitta namuna (bitta kvartira)"},
    {"Tushuncha": "Matritsa", "Kodda": "X.shape = (n, m)", "ML da": "n namuna, m xususiyat"},
    {"Tushuncha": "Skalyar ko'paytma", "Kodda": "x @ w + b", "ML da": "BITTA bashorat — eng muhim amal"},
    {"Tushuncha": "Matritsa ko'paytirish", "Kodda": "X @ w + b", "ML da": "HAMMA bashorat birdan"},
    {"Tushuncha": "Shakl qoidasi", "Kodda": "(n,m) @ (m,k) = (n,k)", "ML da": "Xatolarning yarmi shu yerda"},
    {"Tushuncha": "Transpose", "Kodda": "X.T", "ML da": "X.T @ X — normal tenglama va PCA"},
    {"Tushuncha": "Broadcasting", "Kodda": "X - X.mean(axis=0)", "ML da": "StandardScaler ning ichi"},
    {"Tushuncha": "L1 / L2 norma", "Kodda": "np.linalg.norm(w, 1/2)", "ML da": "Lasso va Ridge (16-bob)"},
]))