IlmHamroh
Data Science va sun'iy intellekt/Chiziqli algebra4/10-dars20 daqiqa
Mundarija (22)

10.4-dars: Matritsa ko'paytmasi va chiziqli o'zgartirishlar

10-QISM — CHIZIQLI ALGEBRA · 4-dars

1. Kirish va motivatsiya

2.11-darsda matritsa ko'paytmasini (@) hisoblashni o'rgandik: shakl qoidasi (m × n) @ (n × k) = (m × k). Bu darsda uning ma'nosini ochamiz: matritsa — bu chiziqli o'zgartirish (funksiya), vektorni boshqa vektorga aylantiradi. Aylantirish, cho'zish, aks ettirish, proyeksiya — hammasi matritsa. Ikki matritsa ko'paytmasi — ikki o'zgartirishni ketma-ket bajarish.

Bu nuqtai nazar Data Science'da juda kuchli: chiziqli regressiya bashorati — X @ w (har qatorni og'irliklar bilan skalyar ko'paytirish); neyron tarmoq qatlami — X @ W + b (keyin aktivatsiya); PCA — ma'lumotni yangi o'qlarga o'tkazish (X @ V); standartlashtirish — diagonal matritsa; rasmni burish/cho'zish — 2 × 2 matritsa; Markov zanjiri — holatlar ehtimoli matritsa bilan keyingi qadamga o'tadi. Matritsani "harakat" sifatida ko'rish — bu formulalarni tushunishning kaliti.

Real vaziyat. Onlayn do'kon mijozlarning oylik holatini kuzatadi: "faol", "sust", "ketgan". Tarixiy ma'lumotdan o'tish ehtimollari matritsasi P tuziladi (masalan, faol mijoz keyingi oy 80% faol qoladi, 15% sust, 5% ketadi). Bugungi taqsimot vektori s = [0.7, 0.2, 0.1]. Menejer so'raydi: "6 oydan keyin qancha faol mijoz qoladi?". Javob — s @ P @ P @ ... (6 marta) = s @ P^6. Bitta qator kod. Matritsa ko'paytmasini o'zgartirish sifatida tushunish — biznes bashoratini bir necha soniyada berdi.

Bu darsda matritsa ko'paytmasini chiziqli o'zgartirish sifatida o'rganamiz.

Bu darsda:

  • Matritsa ko'paytmasi: uch xil o'qish
  • Matritsa — chiziqli o'zgartirish
  • 2D o'zgartirishlar: cho'zish, burish, aks, proyeksiya
  • Ko'paytmalar zanjiri (ketma-ket o'zgartirish)
  • Ko'paytma xossalari (AB ≠ BA)
  • Chiziqli model va neyron qatlami
  • Matritsa ko'paytmasi tuzoqlari
  • Amaliy: Markov zanjiri (mijozlar holati)

ℹ Misollar real numpy bilan (Python 3.14).

2. Nazariya — chuqur tushuntirish

2.1. Matritsa ko'paytmasi: uch xil o'qish

text
C = A @ B       A: (m × n),  B: (n × k)  →  C: (m × k)   ← ichki o'lchamlar teng!

1) ELEMENT:   C[i, j] = A ning i-qatori · B ning j-ustuni   (skalyar ko'paytma, 10.2)
2) USTUN:     C ning j-ustuni = A @ (B ning j-ustuni)       (A — o'zgartirish)
3) QATOR:     C ning i-qatori = (A ning i-qatori) @ B

X @ w  (n × p) @ (p,)  →  (n,)   har kuzatuv uchun bashorat

Matritsa ko'paytmasi — skalyar ko'paytmalar jadvali: har element — bir qator va bir ustunning skalyar ko'paytmasi. Shart: ichki o'lchamlar teng (A ning ustunlari = B ning qatorlari). Uch o'qish bir xil natija beradi, lekin turli intuitsiya: element — "o'xshashliklar jadvali" (X @ X.T, 10.3); ustun — "A har ustunni o'zgartiradi"; qator — "har kuzatuv B bilan o'zgartiriladi" (X @ W — neyron qatlami). NumPy: A @ B (np.dot ham, lekin @ aniqroq).

2.2. Matritsa — chiziqli o'zgartirish

text
y = A @ x      — A x vektorini y vektoriga aylantiradi

Chiziqli degani:  A @ (x + z) = A @ x + A @ z
                  A @ (c × x) = c × (A @ x)
                  A @ 0 = 0          (boshlanish nuqtasi joyida qoladi)

A ning ustunlari = asos vektorlar qayerga boradi:
  A = [[2, 0],       [1, 0] → [2, 1]   (1-ustun)
       [1, 3]]       [0, 1] → [0, 3]   (2-ustun)

Chiziqli o'zgartirish — to'g'ri chiziqlarni to'g'ri chiziqqa, boshlanishni boshlanishga o'tkazuvchi funksiya; har bunday funksiya — matritsa. Eng muhim kalit: A ning ustunlari — o'qlarning (asos vektorlarning) yangi joyi. Shuning uchun matritsaga qarab, o'zgartirishni "ko'rish" mumkin. Siljitish (x + b) chiziqli emas — shuning uchun ML'da "+ b" (bias) alohida yoziladi (affin o'zgartirish).

2.3. 2D o'zgartirishlar

text
CHO'ZISH:     [[a, 0], [0, b]]                  x ni a, y ni b marta
BURISH:       [[cos t, -sin t], [sin t, cos t]] t burchakka (uzunlik saqlanadi)
AKS (x o'qi): [[1, 0], [0, -1]]
SILJISH:      [[1, k], [0, 1]]                   (shear — qiyshaytirish)
PROYEKSIYA:   [[1, 0], [0, 0]]                   x o'qiga (y yo'qoladi!)

2D da har o'zgartirishni ko'z bilan ko'rish mumkin: cho'zish (diagonal — standartlashtirish), burish (ortogonal matritsa — uzunlik va burchaklarni saqlaydi; PCA — koordinatalar tizimini burish), aks, qiyshaytirish, proyeksiya (o'lchamni yo'qotadi — qaytarib bo'lmaydi; 10.5 — teskari matritsa yo'q). Ko'p o'lchamda xuddi shu turlar ishlaydi — faqat chizib bo'lmaydi.

2.4. Ko'paytmalar zanjiri

Ketma-ket o'zgartirish: avval B, keyin A — bu A @ B (o'ngdan chapga o'qiladi — x ga birinchi B ta'sir qiladi: A @ (B @ x)). Qator-vektor konventsiyasida (x @ B @ A) — chapdan o'ngga. Zanjir bitta matritsaga "yig'iladi": M = A @ B — bir marta hisoblab, ko'p marta qo'llash tejamli. Daraja: P^k = P @ P @ ... (k marta) — takroriy jarayon (Markov zanjiri, 2.8). np.linalg.matrix_power(P, k). Muhim: chiziqli qatlamlar zanjiri — yana bitta chiziqli qatlam! (Neyron tarmoqda aktivatsiya funksiyasi nochiziqlilik uchun kerak — aks holda 100 qatlam = 1 qatlam.)

2.5. Ko'paytma xossalari

text
A @ B ≠ B @ A              (tartib muhim! — avval burib keyin cho'zish ≠ aksincha)
(A @ B) @ C = A @ (B @ C)  (assotsiativ — qavslar joyi natijani o'zgartirmaydi)
A @ (B + C) = A @ B + A @ C
A @ I = I @ A = A
(A @ B).T = B.T @ A.T

Hisoblash narxi: (m × n) @ (n × k) — taxminan m × n × k ko'paytirish
  (X.T @ X) @ w  va  X.T @ (X @ w) — natija bir xil, narx juda farq qilishi mumkin

Kommutativ emas: A @ B ≠ B @ A (umuman olganda; hatto shakli ham mos kelmasligi mumkin). Assotsiativ: qavslar natijani o'zgartirmaydi — lekin tezlikni o'zgartiradi: n = 1 000 000, p = 100 da X.T @ (X @ w) — ikki matritsa-vektor ko'paytmasi (tez), (X.T @ X) @ w — avval p × p matritsa (bu ham yaxshi); lekin (X @ X.T) @ v — n × n matritsa (imkonsiz, 10.3). To'g'ri qavs — to'g'ri algoritm.

2.6. Chiziqli model va neyron qatlami

text
CHIZIQLI REGRESSIYA:    y_hat = X @ w + b           (n × p) @ (p,) → (n,)
KO'P CHIQISHLI:         Y_hat = X @ W + b           (n × p) @ (p × k) → (n × k)
NEYRON QATLAMI:         H = f(X @ W + b)            f — aktivatsiya (ReLU, sigmoid)
IKKI QATLAM:            Y = f2(f(X @ W1 + b1) @ W2 + b2)

Batch: butun ma'lumot bir marta ko'paytiriladi — GPU shuning uchun tez

ML modellarining "dvigateli" — matritsa ko'paytmasi. Chiziqli regressiya — X @ w: har qator og'irliklar bilan skalyar ko'paytiriladi. Neyron qatlami — X @ W: p belgini k ta yangi belgiga o'zgartirish (W — p × k), keyin nochiziqli funksiya. Butun ma'lumotni bir marta matritsa ko'paytmasi bilan ishlash (batch) — sikldan yuzlab marta tez; GPU aynan matritsa ko'paytmasi uchun yaratilgan. sklearn LinearRegression().predict(X) — ichida X @ coef_ + intercept_.

2.7. Matritsa ko'paytmasi tuzoqlari

Asosiy tuzoqlar: * va @ (element bo'yicha va matritsa — shakl mos bo'lsa xato bermaydi, noto'g'ri natija beradi!); tartib (A @ B ≠ B @ A; o'zgartirishlar ketma-ketligi); shakl xatosi (ichki o'lchamlar mos emas — ValueError: matmul: ... mismatch; odatda transponirlash kerak); 1D vektorlar (v @ A va A @ v — NumPy (n,) ni avtomatik qator/ustun qiladi — qulay, lekin chalkash); qavslar va narx (n × n oraliq matritsa — xotira); np.matrix eskirgan (* u yerda matritsa ko'paytmasi — chalkashlik; faqat ndarray va @); chiziqli qatlamlar zanjiri (aktivatsiyasiz — bitta qatlam).

2.8. Matritsa ko'paytmasi — o'zgartirishlar tili

Matritsa ko'paytmasi: ichki o'lchamlar teng, natija (m × k); element — skalyar ko'paytma; matritsa — chiziqli o'zgartirish (ustunlar — o'qlarning yangi joyi); 2D turlari — cho'zish, burish, aks, qiyshaytirish, proyeksiya; zanjir — A @ B (avval B), daraja P^k (Markov); xossalar — kommutativ emas, assotsiativ (qavs — tezlik); ML — X @ w (regressiya), f(X @ W + b) (neyron), batch — GPU. Keyingi dars — chiziqli tenglamalar sistemasi: o'zgartirishni "orqaga" qaytarish (teskari matritsa, determinant, rank).

3. Tez ma'lumotnoma

python
import numpy as np

A @ B                                  # matritsa ko'paytmasi (ichki o'lchamlar teng)
A * B                                  # element bo'yicha (boshqa narsa!)
X @ w + b                              # chiziqli model bashorati
np.maximum(0, X @ W + b)               # ReLU neyron qatlami

np.linalg.matrix_power(P, 6)           # P^6 (Markov)

t = np.radians(30)
R = np.array([[np.cos(t), -np.sin(t)], [np.sin(t), np.cos(t)]])   # burish
S = np.diag([2, 0.5])                  # cho'zish
M = R @ S                              # avval S, keyin R

# qavs — tezlik
X.T @ (X @ w)                          # tez
# (X @ X.T) @ v                        # n × n — qoching
QOIDA: @ — matritsa, * — element · ichki o'lchamlar · A @ B ≠ B @ A · to'g'ri qavs

Matritsa ko'paytmasi xulosasi

(m × n) @ (n × k) = (m × k); C[i,j] = qator · ustun
Matritsa — chiziqli o'zgartirish; ustunlar — o'qlar yangi joyi
Cho'zish, burish, aks, qiyshaytirish, proyeksiya
A @ B — avval B, keyin A; P^k — k qadam
A @ B ≠ B @ A; assotsiativ (qavs — tezlik)
Regressiya X @ w; neyron f(X @ W + b)

4. Batafsil misollar

Misollar real numpy bilan (Python 3.14).

Misol 1 — Uch o'qish va shakl qoidasi

python
"""Matritsa ko'paytmasi: element, ustun, qator o'qishlari (real numpy)."""

import numpy as np


def main() -> None:
    A = np.array([[1, 2], [3, 4], [5, 6]])        # 3 × 2
    B = np.array([[1, 0, 2], [0, 1, 1]])          # 2 × 3
    C = A @ B

    print("=== 1. Shakl ===")
    print(f"  (3×2) @ (2×3) = {C.shape}")
    print(C)

    print("\n=== 2. Element = qator · ustun ===")
    print(f"  C[2, 2] = A[2] · B[:, 2] = {A[2]} · {B[:, 2]} = {A[2] @ B[:, 2]}")

    print("\n=== 3. Ustun o'qishi ===")
    print(f"  C[:, 0] = A @ B[:, 0] = {A @ B[:, 0]}")

    print("\n=== 4. * va @ farqi ===")
    K = np.array([[1, 2], [3, 4]])
    print(f"  K * K = {(K * K).tolist()}  (element bo'yicha)")
    print(f"  K @ K = {(K @ K).tolist()}  (matritsa)")

    print("\n=== 5. Shakl xatosi ===")
    try:
        A @ A
    except ValueError as e:
        print(f"  A @ A: ValueError (3×2 @ 3×2 — ichki 2 ≠ 3)")
    print(f"  A.T @ A shakli: {(A.T @ A).shape}")
    print("  ⭐ Ichki o'lchamlar teng bo'lishi shart")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Shakl ===
  (3×2) @ (2×3) = (3, 3)
[[ 1  2  4]
 [ 3  4 10]
 [ 5  6 16]]

=== 2. Element = qator · ustun ===
  C[2, 2] = A[2] · B[:, 2] = [5 6] · [2 1] = 16

=== 3. Ustun o'qishi ===
  C[:, 0] = A @ B[:, 0] = [1 3 5]

=== 4. * va @ farqi ===
  K * K = [[1, 4], [9, 16]]  (element bo'yicha)
  K @ K = [[7, 10], [15, 22]]  (matritsa)

=== 5. Shakl xatosi ===
  A @ A: ValueError (3×2 @ 3×2 — ichki 2 ≠ 3)
  A.T @ A shakli: (2, 2)
  ⭐ Ichki o'lchamlar teng bo'lishi shart

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

Misol 2 — 2D o'zgartirishlar va tartib

python
"""Matritsa — o'zgartirish: cho'zish, burish, proyeksiya; A @ B ≠ B @ A (real numpy)."""

import numpy as np


def main() -> None:
    kvadrat = np.array([[0, 0], [1, 0], [1, 1], [0, 1]], dtype=float).T   # 2 × 4 (ustunlar — nuqtalar)

    t = np.radians(90)
    R = np.array([[np.cos(t), -np.sin(t)], [np.sin(t), np.cos(t)]])
    S = np.diag([2.0, 0.5])
    P = np.array([[1.0, 0.0], [0.0, 0.0]])

    print("=== 1. Ustunlar — o'qlarning yangi joyi ===")
    print(f"  S: [1,0] → {S @ [1, 0]}, [0,1] → {S @ [0, 1]}")

    print("\n=== 2. Kvadrat nuqtalari ===")
    for nom, M in [("cho'zish", S), ("burish 90°", R), ("proyeksiya", P)]:
        print(f"  {nom:<11}: {np.round(M @ kvadrat, 2).T.tolist()}")

    print("\n=== 3. Burish uzunlikni saqlaydi ===")
    v = np.array([3.0, 4.0])
    print(f"  ||v|| = {np.linalg.norm(v)}, ||R v|| = {np.linalg.norm(R @ v):.1f}")

    print("\n=== 4. Tartib muhim ===")
    print(f"  R @ S = {np.round(R @ S, 2).tolist()}")
    print(f"  S @ R = {np.round(S @ R, 2).tolist()}")
    print(f"  teng: {np.allclose(R @ S, S @ R)}")
    print("  ⭐ A @ B — avval B, keyin A; tartib almashsa natija boshqa")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Ustunlar — o'qlarning yangi joyi ===
  S: [1,0] → [2. 0.], [0,1] → [0.  0.5]

=== 2. Kvadrat nuqtalari ===
  cho'zish   : [[0.0, 0.0], [2.0, 0.0], [2.0, 0.5], [0.0, 0.5]]
  burish 90° : [[0.0, 0.0], [0.0, 1.0], [-1.0, 1.0], [-1.0, 0.0]]
  proyeksiya : [[0.0, 0.0], [1.0, 0.0], [1.0, 0.0], [0.0, 0.0]]

=== 3. Burish uzunlikni saqlaydi ===
  ||v|| = 5.0, ||R v|| = 5.0

=== 4. Tartib muhim ===
  R @ S = [[0.0, -0.5], [2.0, 0.0]]
  S @ R = [[0.0, -2.0], [0.5, 0.0]]
  teng: False
  ⭐ A @ B — avval B, keyin A; tartib almashsa natija boshqa

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

Misol 3 — Chiziqli model va neyron qatlami

python
"""X @ w — regressiya, f(X @ W + b) — neyron qatlami, aktivatsiyasiz zanjir (real numpy/sklearn)."""

import numpy as np
from sklearn.linear_model import LinearRegression


def main() -> None:
    rng = np.random.default_rng(0)
    X = rng.normal(size=(200, 3))
    y = X @ np.array([2.0, -1.0, 0.5]) + 3 + rng.normal(0, 0.1, 200)

    print("=== 1. sklearn predict = X @ coef + intercept ===")
    m = LinearRegression().fit(X, y)
    qolda = X @ m.coef_ + m.intercept_
    print(f"  coef = {np.round(m.coef_, 2)}, intercept = {m.intercept_:.2f}")
    print(f"  bir xil: {np.allclose(qolda, m.predict(X))}")

    print("\n=== 2. Neyron qatlami: 3 belgi → 4 yashirin ===")
    W1 = rng.normal(size=(3, 4)); b1 = np.zeros(4)
    H = np.maximum(0, X @ W1 + b1)                # ReLU
    print(f"  X {X.shape} @ W1 {W1.shape} → H {H.shape}")

    print("\n=== 3. Aktivatsiyasiz 2 qatlam = 1 qatlam ===")
    W2 = rng.normal(size=(4, 1))
    ikki = (X @ W1) @ W2
    bitta = X @ (W1 @ W2)
    print(f"  (X@W1)@W2 == X@(W1@W2): {np.allclose(ikki, bitta)}, W1@W2 shakli {(W1 @ W2).shape}")
    print("  ⭐ Nochiziqlilik (ReLU) bo'lmasa, chuqurlik foydasiz")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. sklearn predict = X @ coef + intercept ===
  coef = [ 1.99 -1.01  0.51], intercept = 3.00
  bir xil: True

=== 2. Neyron qatlami: 3 belgi → 4 yashirin ===
  X (200, 3) @ W1 (3, 4) → H (200, 4)

=== 3. Aktivatsiyasiz 2 qatlam = 1 qatlam ===
  (X@W1)@W2 == X@(W1@W2): True, W1@W2 shakli (3, 1)
  ⭐ Nochiziqlilik (ReLU) bo'lmasa, chuqurlik foydasiz

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

Misol 4 — Markov zanjiri: mijozlar holati

python
"""Markov zanjiri: s @ P^k — mijozlar holati bashorati (real numpy)."""

import numpy as np


def main() -> None:
    holat = ["faol", "sust", "ketgan"]
    P = np.array([
        [0.80, 0.15, 0.05],     # faol → ...
        [0.30, 0.50, 0.20],     # sust → ...
        [0.00, 0.00, 1.00],     # ketgan — qaytmaydi
    ])
    s = np.array([0.7, 0.2, 0.1])

    print("=== 1. Qator yig'indilari (ehtimol) ===")
    print(f"  {P.sum(axis=1)}")

    print("\n=== 2. Oylar bo'yicha taqsimot ===")
    for k in [1, 3, 6, 12]:
        t = s @ np.linalg.matrix_power(P, k)
        print(f"  {k:>2} oy: " + ", ".join(f"{h} {p:.1%}" for h, p in zip(holat, t)))

    print("\n=== 3. Ushlab qolish kampaniyasi: sust → faol 30% dan 45% ga ===")
    P2 = P.copy()
    P2[1] = [0.45, 0.40, 0.15]
    for nom, M in [("hozirgi", P), ("kampaniya", P2)]:
        t = s @ np.linalg.matrix_power(M, 6)
        print(f"  {nom:<9}: 6 oydan keyin faol {t[0]:.1%}, ketgan {t[2]:.1%}")
    print("  ⭐ Takroriy jarayon — matritsa darajasi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Qator yig'indilari (ehtimol) ===
  [1. 1. 1.]

=== 2. Oylar bo'yicha taqsimot ===
   1 oy: faol 62.0%, sust 20.5%, ketgan 17.5%
   3 oy: faol 50.5%, sust 18.1%, ketgan 31.4%
   6 oy: faol 37.9%, sust 13.8%, ketgan 48.3%
  12 oy: faol 21.5%, sust 7.9%, ketgan 70.7%

=== 3. Ushlab qolish kampaniyasi: sust → faol 30% dan 45% ga ===
  hozirgi  : 6 oydan keyin faol 37.9%, ketgan 48.3%
  kampaniya: 6 oydan keyin faol 44.7%, ketgan 42.6%
  ⭐ Takroriy jarayon — matritsa darajasi

Nima ko'rsatdi: 2.4-bo'lim.

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

Noto'g'ri fikr To'g'risi
"A @ B = B @ A" Umuman teng emas
"A * B — matritsa ko'paytmasi" Element bo'yicha (ndarray)
"Matritsa — faqat jadval" Chiziqli o'zgartirish
"A @ B — avval A" Avval B (x ga B ta'sir qiladi)
"Ko'p chiziqli qatlam — kuchli model" Aktivatsiyasiz — bitta qatlam
"Qavslar farqsiz" Natija bir, narx farqli
"Siljitish (+ b) — matritsa" Chiziqli emas (affin)
"Proyeksiyani qaytarish mumkin" Ma'lumot yo'qoladi

6. Keng tarqalgan xatolar va yechimlari

1. * bilan matritsa ko'paytmasi

python
y_hat = X * w                          # broadcasting — (n, p)      # ⚠️
y_hat = X @ w                          # (n,)                       # ✅

2. Shakl xatosi

python
Z = X @ W                              # (n, p) @ (k, p) — xato     # ⚠️
Z = X @ W.T                            # (n, p) @ (p, k)            # ✅

3. Tartib

python
M = S @ R          # "avval S, keyin R" deb                         # ⚠️
M = R @ S          # avval S, keyin R                               # ✅

4. Qimmat qavs

python
g = (X @ X.T) @ v                      # n × n                      # ⚠️
g = X @ (X.T @ v)                      # p o'lchamli oraliq         # ✅

5. Siklda daraja

python
for _ in range(12): s = s @ P          # to'g'ri, lekin              # ⚠️ (sekinroq)
s12 = s @ np.linalg.matrix_power(P, 12)                            # ✅

6. np.matrix

python
M = np.matrix(A); M * M                # eskirgan, chalkash         # ⚠️
A @ A                                                              # ✅

7. Aktivatsiyasiz "chuqur" tarmoq

python
H = X @ W1 @ W2 @ W3                   # bitta chiziqli qatlam      # ⚠️
H = relu(relu(X @ W1) @ W2) @ W3                                   # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 2.11-dars (o'tilgan): @ va shakl qoidasi
  • 10.2-10.3-darslar (o'tilgan): Skalyar ko'paytma, matritsalar
  • 10.5-dars: Teskari matritsa (o'zgartirishni qaytarish)
  • 10.9-dars: PCA — koordinatalarni burish
  • Deep Learning qismi: Qatlamlar, batch, GPU

8. Eng yaxshi amaliyotlar

  1. Matritsa ko'paytmasi — faqat @.

  2. Har ko'paytmadan oldin shaklni tekshiring.

  3. Matritsani o'zgartirish sifatida tasavvur qiling (ustunlar — o'qlar).

  4. Ketma-ketlik: o'ngdagi birinchi ta'sir qiladi.

  5. Qavslarni narx bo'yicha qo'ying (n × n dan qoching).

  6. Batch — butun X bir marta.

  7. Daraja — matrix_power.

  8. Neyron qatlamlar orasida nochiziqlilik.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # (4 × 3) @ (3 × 2) shakli?
2.  # (4 × 3) @ (4 × 3)?
3.  # [[1, 2], [3, 4]] @ [1, 1]?
4.  # np.diag([3, 1]) @ [2, 5]?
5.  # 90° burish [1, 0] ni qayerga?
6.  # [[1, 0], [0, 0]] @ [3, 7]?
7.  # A @ B = B @ A doimmi?
8.  # (A @ B) @ C = A @ (B @ C)?
9.  # X (1000 × 20) @ W (20 × 64) shakli?
10. # aktivatsiyasiz 3 qatlam = ?
11. # Markov: P qator yig'indisi?
12. # s @ P^k nimani beradi?
Javoblar
  1. 4 × 2
  2. Xato (3 ≠ 4)
  3. [3, 7]
  4. [6, 5]
  5. [0, 1]
  6. [3, 0]
  7. Yo'q
  8. Ha
  9. 1000 × 64
  10. Bitta chiziqli qatlam
  11. 1
  12. k qadamdan keyingi holatlar taqsimoti

Vazifa 2: Xatolarni tuzating

python
1.  y_hat = X * w   # chiziqli model

2.  Z = X @ W   # X (n, 5), W (8, 5)

3.  M = S @ R   # avval cho'zish (S), keyin burish (R)

4.  g = (X @ X.T) @ v   # n = 1 000 000

5.  H = X @ W1 @ W2   # 2 qatlamli neyron tarmoq
Javoblar
python
1.  y_hat = X @ w

2.  Z = X @ W.T

3.  M = R @ S

4.  g = X @ (X.T @ v)

5.  H = np.maximum(0, X @ W1) @ W2

Vazifa 3: O'zgartirishlar

Modellang:

  1. Uchburchak nuqtalari (2 × 3)
  2. Cho'zish, 45° burish, aks
  3. Uchta ketma-ketlik (turli tartib)
  4. Natijalarni solishtirish

Vazifa 4: Neyron qatlami

Modellang:

  1. X (100 × 4)
  2. W1 (4 × 8), W2 (8 × 1)
  3. ReLU bilan va ReLU'siz
  4. Aktivatsiyasiz modelni bitta W bilan ifodalash

Vazifa 5: Markov

Modellang:

  1. Veb-sayt sahifalari o'tishlari (4 holat)
  2. 1, 5, 20 qadamdan keyin taqsimot
  3. Barqaror taqsimot (katta k)
  4. Bitta o'tish ehtimolini o'zgartirish ta'siri

Vazifa 6: Integratsiya

Modellang:

  1. Skalyar ko'paytma (10.2)
  2. Diagonal matritsa (10.3)
  3. LinearRegression.predict
  4. Broadcasting (2.6)

Vazifa 7: O'ylash

Neyron tarmoqlar asosan matritsa ko'paytmalaridan iborat, lekin ular rasm tanish, tarjima qilish kabi juda murakkab (nochiziqli) vazifalarni bajaradi. Agar matritsa ko'paytmasi faqat chiziqli o'zgartirish bo'lsa (cho'zish, burish, proyeksiya), bu murakkablik qayerdan keladi? Nega GPU aynan matritsa ko'paytmasi uchun juda muhim?

Javob

Qisqa javob: murakkablik chiziqli o'zgartirishlar va oddiy nochiziqli funksiyalar (ReLU) navbatlashishidan keladi. Har qatlam fazoni buradi/cho'zadi (matritsa), keyin "bukadi" (ReLU manfiylarni kesadi). Ko'p qatlamda bu bukishlar murakkab egri chegaralarni hosil qiladi. Hisoblashning deyarli hammasi — matritsa ko'paytmasi, GPU esa minglab ko'paytirishni parallel bajaradi.

1. Murakkablik qayerdan

Qism Nima qiladi
X @ W Fazoni burish, cho'zish, proyeksiya (chiziqli)
+ b Siljitish
ReLU Bukish: yarim fazoni kesish (nochiziqli)
Ko'p qatlam Bukishlar birikmasi → murakkab funksiya
  • Aktivatsiyasiz: 100 qatlam = bitta matritsa (Misol 3)
  • Aktivatsiya bilan: universal yaqinlashtirish — yetarli neyron bilan har qanday uzluksiz funksiyaga yaqinlashish mumkin

2. Nega GPU

  • Matritsa ko'paytmasi — millionlab mustaqil ko'paytirish-qo'shish
  • CPU: bir necha kuchli yadro, ketma-ket
  • GPU: minglab oddiy yadro — hammasi bir vaqtda
  • Batch (butun X bir marta) — GPU'ni to'liq yuklaydi

3. Hisob misoli

  • Qatlam: (batch 256 × 1024) @ (1024 × 1024) ≈ 268 mln ko'paytirish
  • Katta model: milliardlab parametr — trillionlab amal har qadamda
  • GPU bo'lmasa, zamonaviy deep learning amalda imkonsiz

4. Data Scientist uchun ma'nosi

  1. Modelni "matritsa + nochiziqlilik" zanjiri sifatida tushunish
  2. Shakllarni kuzatish — xatolarning ko'pi shakl xatosi
  3. Batch o'lchami va xotira muvozanati
  4. Vektorlashtirilgan kod — CPU'da ham tez

5. Xulosa

  1. Matritsa — chiziqli qism (burish, cho'zish)
  2. Aktivatsiya — bukish; murakkablik navbatlashishdan
  3. Deep learning hisobining asosi — matritsa ko'paytmasi
  4. GPU — parallel matritsa ko'paytmasi mashinasi

Nimani mustahkamlaydi: 2.4, 2.6-bo'limlar.

Xulosa

Bu darsda matritsa ko'paytmasini chiziqli o'zgartirish sifatida o'rgandik.

Eng muhim uch fikr:

  1. Hisob va shakl. (m × n) @ (n × k) = (m × k) — ichki o'lchamlar teng; har element — qator va ustun skalyar ko'paytmasi. @ — matritsa, * — element bo'yicha (shakl mos kelsa ham natija boshqa!).

  2. Matritsa — o'zgartirish. Ustunlar — o'qlarning yangi joyi; cho'zish (diagonal), burish (uzunlik saqlanadi), aks, qiyshaytirish, proyeksiya (ma'lumot yo'qoladi). A @ B — avval B, keyin A; A @ B ≠ B @ A; assotsiativ — qavslar tezlikni belgilaydi (n × n oraliqdan qoching). P^k — takroriy jarayon (Markov zanjiri).

  3. ML dvigateli. Regressiya — X @ w + b; neyron qatlami — f(X @ W + b); aktivatsiyasiz qatlamlar zanjiri — bitta chiziqli qatlam. Batch va GPU — matritsa ko'paytmasining parallelligi.

Keyingi darsda chiziqli tenglamalar sistemasini o'rganamiz: A @ x = b ni yechish, teskari matritsa (o'zgartirishni qaytarish), determinant va rank — qachon yechim bor, qachon yo'q.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
10.4-dars: Matritsa ko'paytmasi va chiziqli o'zgartirishlar — IlmHamroh