Data Science va sun'iy intellekt/NumPy11/14-dars19 daqiqa

Mundarija (22)

2.11-dars: Chiziqli algebra

2-QISM — NUMPY · 11-dars

1. Kirish va motivatsiya

Machine Learning va Deep Learning matematikasi — bu chiziqli algebra. Har bir model (chiziqli regressiya, neyron tarmoq) asosida matritsa ko'paytmasi yotadi. NumPy buni beradi: dot (skalyar ko'paytma), @ yoki matmul (matritsa ko'paytmasi), .T (transpose — 2.7). Bu darsda 2.5'dagi a * b (element-wise) va matritsa ko'paytmasi (a @ b) o'rtasidagi muhim farqni tushunamiz — ular butunlay boshqa amallar. Nega muhim? (1) ML asosi — chiziqli model y = X @ w + b (matritsa ko'paytmasi); (2) Deep Learning — neyron qatlamlar matritsa ko'paytmasi (22-qism); (3) Samaradorlik — matritsa ko'paytmasi vektorlashtirilgan (tez, GPU). Bu chiziqli algebrani chuqur o'rgatadi — ML matematikasining yuragi. (Eslatma: bu asosiy tanishtiruv; chuqur chiziqli algebra 3-qismda.)

Chiziqli algebra — vektor/matritsa ko'paytmasi: skalyar ko'paytma (np.dot(a, b) — vektorlar — mos elementlar ko'paytmasi yig'indisi), matritsa ko'paytmasi (a @ b yoki np.matmul — qator × ustun), element-wise farqi (a * b element-wise ≠ a @ b matritsa — 2.5), transpose (.T — qator↔ustun, 2.7), birlik matritsa (np.eye), shakl qoidasi ((m,n) @ (n,p) = (m,p) — ichki o'lcham mos). Foydalanish: ML modellar, chiziqli regressiya, neyron tarmoq. Bu 2.5 (vektorlashtirish), 22-qism (DL) bilan bog'liq. dot — skalyar ko'paytma. @ — matritsa. ML matematikasi.

Real vaziyat. Data Scientist chiziqli regressiya modelini qo'lda hisoblamoqchi edi: bashorat = X @ w (X — ma'lumot matritsasi 100×3, w — vaznlar 3×1). X @ w (matritsa ko'paytmasi) — har namuna uchun bashorat (100×1). Avvaliga X * w (element-wise) qildi — xato (shakl mos emas yoki noto'g'ri natija); @ (matritsa) to'g'ri edi. Skalyar ko'paytma (np.dot(a, b)) — ikki vektor o'xshashligi (kosinus — tavsiya tizimi). Shakl qoidasi ((100,3) @ (3,1) = (100,1) — ichki 3 mos). @ va * butunlay boshqa (matritsa vs element-wise). Chiziqli algebra — ML/DL matematik asosi (har model matritsa ko'paytmasi).

Bu darsda chiziqli algebrani o'rganamiz.

Bu darsda:

Skalyar ko'paytma (dot)
Matritsa ko'paytmasi (@)
Element-wise vs matritsa (muhim farq)
Shakl qoidasi
transpose va birlik matritsa
Chiziqli algebra amaliyoti
Chiziqli algebra tuzoqlari
Amaliy: ML hisobi modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Skalyar ko'paytma (dot)

Ikki vektor → bitta son:

python

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

np.dot(a, b)    # 32 (1*4 + 2*5 + 3*6 = 4+10+18)
a @ b           # 32 (bir xil — 1D uchun)
a.dot(b)        # 32

# mos elementlar ko'paytmasi YIG'INDISI (bitta son)

Skalyar ko'paytma (dot) — ikki vektor → bitta son: np.dot(a, b) (mos elementlar ko'paytmasi yig'indisi — 1*4 + 2*5 + 3*6 = 32), a @ b (bir xil — 1D), a.dot(b). Sabab: ikki vektor o'xshashligi/proyeksiyasi (kosinus o'xshashlik — tavsiya tizimi, NLP; chiziqli birikma — model); skalyar ko'paytma bitta son (mos ko'paytma yig'indi). a * b (element-wise — massiv [4,10,18]) ≠ np.dot (bitta son 32 — yig'indi). "Skalyar" = bitta son (natija). Skalyar ko'paytma — mos ko'paytma yig'indi (dot, bitta son). Vektor. O'xshashlik.

2.2. Matritsa ko'paytmasi (@)

Matritsalar ko'paytmasi:

python

A = np.array([[1, 2], [3, 4]])      # 2×2
B = np.array([[5, 6], [7, 8]])      # 2×2

A @ B           # matritsa ko'paytmasi
# [[19 22]      (1*5+2*7, 1*6+2*8)
#  [43 50]]     (3*5+4*7, 3*6+4*8)

np.matmul(A, B) # bir xil (@)
A.dot(B)        # bir xil

Matritsa ko'paytmasi (@) — matritsalar ko'paytmasi: A @ B (yoki np.matmul(A, B), A.dot(B)) — qator × ustun (natija[i,j] = A ning i-qatori · B ning j-ustuni — skalyar ko'paytma). Sabab: ML/DL asosiy amal (chiziqli model X @ w — bashorat; neyron qatlam — matritsa ko'paytma); @ qator×ustun (element-wise emas). A @ B[i,j] = A[i-qator] va B[j-ustun] skalyar ko'paytmasi. @ (Python operator — 3.5+), np.matmul, .dot — bir xil. Matritsa ko'paytmasi — qator × ustun (@). ML asosi. Element-wise emas.

2.3. Element-wise vs matritsa (muhim farq)

Ikki butunlay boshqa amal:

python

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# ELEMENT-WISE (*) — mos elementlar (2.5)
A * B      # [[5 12] [21 32]] (1*5, 2*6, 3*7, 4*8)

# MATRITSA (@) — qator × ustun
A @ B      # [[19 22] [43 50]] (skalyar ko'paytmalar)

# BUTUNLAY BOSHQA NATIJA!

Element-wise vs matritsa (muhim farq) — ikki butunlay boshqa amal: A * B (element-wise — mos elementlar: A[i,j] * B[i,j] — 2.5), A @ B (matritsa — qator × ustun: skalyar ko'paytmalar). Sabab: bu eng ko'p chalkashadigan joy (* va @ — turli amal, turli natija); * (mos element — [[5,12],[21,32]]), @ (qator×ustun — [[19,22],[43,50]]) — butunlay boshqa. ML'da ko'pincha @ kerak (matritsa — model), lekin * (element-wise — masshtablash) ham. Chalkashtirish — jim xato (noto'g'ri natija). Element-wise vs matritsa — * mos element, @ qator×ustun. Butunlay boshqa. Chalkash.

2.4. Shakl qoidasi

Shakl qoidasi — matritsa ko'paytmasi qachon mumkin:

MATRITSA KO'PAYTMASI SHAKL QOIDASI:
   (m, n) @ (n, p) = (m, p)
      ICHKI o'lchamlar MOS bo'lishi kerak (n = n)
      TASHQI o'lchamlar natija shakli (m, p)

   MISOL:
      (100, 3) @ (3, 1) = (100, 1)   OK (ichki 3=3)
      (2, 3) @ (3, 4) = (2, 4)       OK (ichki 3=3)
      (2, 3) @ (2, 3) = XATO         (ichki 3≠2)

Sabab: matritsa ko'paytmasi qator × ustun (birinchi matritsa qatori ikkinchi matritsa ustuni bilan — element soni mos bo'lishi kerak); ichki o'lchamlar (birinchi ustun = ikkinchi qator — n = n) mos; tashqi (birinchi qator, ikkinchi ustun — m, p) natija shakli. (100,3) @ (3,1) — ichki 3=3 OK, natija (100,1); (2,3) @ (2,3) — ichki 3≠2 xato. Shakl qoidasi — ichki mos, tashqi natija ((m,n)@(n,p)=(m,p)). Ichki mos. Natija tashqi.

2.5. transpose va birlik matritsa

transpose va birlik matritsa: .T (transpose — qator↔ustun, 2.7; shakl mos qilish uchun — A.T @ A); birlik matritsa (np.eye(n) — diagonal 1, qolgan 0; matritsa ko'paytmasida o'zgartmaydi — A @ I = A, sonlardagi 1 kabi). Sabab: transpose shakl mos qilish uchun ((m,n) @ (m,p) xato — ichki mos emas; A.T @ B = (n,m) @ (m,p) OK); ML'da tez-tez (X.T @ X — normal tenglama). Birlik matritsa — matritsa "1" (A @ I = A; teskari matritsa — A @ A_teskari = I). transpose/birlik — .T (shakl mos), eye (matritsa 1). Shakl. Birlik.

2.6. Chiziqli algebra amaliyoti

Chiziqli algebra amaliyoti: np.dot (skalyar ko'paytma — vektor, bitta son); @ (matritsa ko'paytmasi — A @ B, ML); * vs @ (element-wise vs matritsa — chalkashtirmang); shakl qoida (ichki mos — (m,n)@(n,p)); .T (shakl mos qilish — A.T @ B); np.eye (birlik matritsa); np.linalg (teskari inv, determinant det — ilg'or); ML formula (y = X @ w + b). Tuzoqlar: * vs @ (element-wise vs matritsa — turli natija), shakl mos emas (ichki — xato), transpose unutish (shakl mos qilish), 1D vs 2D (vektor shakli). Amaliyot — dot, @, *vs@, shakl, .T. Matritsa. ML.

2.7. Chiziqli algebra tuzoqlari

Chiziqli algebra asosiy tuzoqlari: * vs @ (A * B element-wise, A @ B matritsa — butunlay boshqa natija; eng ko'p xato — ML'da @ kerak bo'lsa * yozish, jim noto'g'ri); shakl mos emas ((2,3) @ (2,3) — ichki 3≠2, xato; ichki o'lcham mos bo'lishi kerak); transpose unutish (X @ X xato — X.T @ X kerak, shakl mos); 1D vs 2D (vektor (3,) yoki (3,1) — matritsa ko'paytmasida farq; shakl aniqlik); tartib muhim (A @ B ≠ B @ A — matritsa ko'paytmasi kommutativ emas; tartibni o'zgartmang); np.dot 2D (2D'da dot = matritsa ko'paytma — 1D skalyar, 2D matritsa; chalkash); natija shakl ((m,n)@(n,p) = (m,p) — kutilmagan shakl). Sabab: chiziqli algebra shakl/amal nozik (*/@, shakl, tartib — jim xato yoki noto'g'ri). Yechim: @ matritsa (* element-wise), shakl tekshir, .T. Tuzoqlar — *vs@, shakl, tartib.

2.8. Chiziqli algebra — ML matematikasi

Chiziqli algebra asosiy g'oyasi — ML matematikasi: Machine Learning va Deep Learning matritsa ko'paytmasiga tayanadi (har model — chiziqli regressiya y = X @ w, neyron tarmoq qatlamlar — matritsa ko'paytma); NumPy dot/@ bu amallarni beradi (tez, vektorlashtirilgan). Skalyar ko'paytma (dot — vektorlar, bitta son — o'xshashlik), matritsa ko'paytmasi (@ — qator×ustun — model). Eng muhim: * (element-wise) va @ (matritsa) butunlay boshqa (chalkashtirmang — jim xato). Shakl qoida (ichki mos — (m,n)@(n,p)=(m,p)), transpose (shakl mos — .T). Data Science'da chiziqli algebra poydevor (ML, DL, o'lcham kamaytirish — PCA; tavsiya tizimi — matritsa faktorizatsiya). Bu 2.5 (vektorlashtirish) davomi va 20-qism (ML), 22-qism (DL) uchun matematik asos (chuqur chiziqli algebra — 3-qism/matematika). Chiziqli algebra — ML matematikasi (matritsa ko'paytma). Poydevor. ML/DL.

3. Tez ma'lumotnoma

python

import numpy as np
a = np.array([1, 2, 3]); b = np.array([4, 5, 6])
A = np.array([[1, 2], [3, 4]]); B = np.array([[5, 6], [7, 8]])

# SKALYAR KO'PAYTMA (vektor → bitta son):
np.dot(a, b)   # 32 (1*4+2*5+3*6) · a @ b — bir xil (1D)

# MATRITSA KO'PAYTMASI (qator × ustun):
A @ B          # [[19 22] [43 50]] · np.matmul(A, B)

# ELEMENT-WISE vs MATRITSA (BUTUNLAY BOSHQA!):
A * B          # [[5 12] [21 32]] (mos element — 2.5)
A @ B          # [[19 22] [43 50]] (qator × ustun)

# SHAKL QOIDASI:
#   (m,n) @ (n,p) = (m,p)  — ichki MOS, tashqi natija
#   (100,3) @ (3,1) = (100,1)  OK · (2,3)@(2,3) XATO

# TRANSPOSE (shakl mos):
A.T @ B        # (n,m)@(m,p) — shakl mos qilish

# BIRLIK MATRITSA:
np.eye(3)      # diagonal 1 (A @ I = A)

# ML formula:
y = X @ w + b  # chiziqli model (bashorat)

QOIDA: @ matritsa (* element-wise) · ichki mos · tartib muhim

Chiziqli algebra xulosasi

Chiziqli algebra — ML matematikasi (matritsa ko'paytmasi)
dot — skalyar ko'paytma (vektor → bitta son, o'xshashlik)
@ — matritsa ko'paytmasi (qator × ustun, ML asosi)
* vs @ — element-wise vs matritsa (BUTUNLAY BOSHQA!)
Shakl qoidasi — ichki mos ((m,n)@(n,p)=(m,p))

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — Skalyar ko'paytma (dot)

python

"""Skalyar ko'paytma: dot (real numpy)."""

import numpy as np


def main() -> None:
    a = np.array([1, 2, 3])
    b = np.array([4, 5, 6])

    print("=== 1. dot ===")
    print(f"  np.dot(a, b): {np.dot(a, b)} (1*4+2*5+3*6)")

    print("\n=== 2. @ (1D uchun bir xil) ===")
    print(f"  a @ b: {a @ b}")

    print("\n=== 3. Qo'lda tekshirish ===")
    print(f"  1*4+2*5+3*6 = {1*4 + 2*5 + 3*6}")

    print("\n=== 4. Element-wise farqi ===")
    print(f"  a * b: {a * b} (massiv), dot: {np.dot(a, b)} (bitta son)")
    print("  ⭐ Skalyar ko'paytma — mos ko'paytma yig'indisi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. dot ===
  np.dot(a, b): 32 (1*4+2*5+3*6)

=== 2. @ (1D uchun bir xil) ===
  a @ b: 32

=== 3. Qo'lda tekshirish ===
  1*4+2*5+3*6 = 32

=== 4. Element-wise farqi ===
  a * b: [ 4 10 18] (massiv), dot: 32 (bitta son)
  ⭐ Skalyar ko'paytma — mos ko'paytma yig'indisi

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Matritsa ko'paytmasi (@)

python

"""Matritsa ko'paytmasi: @ (real numpy)."""

import numpy as np


def main() -> None:
    A = np.array([[1, 2], [3, 4]])
    B = np.array([[5, 6], [7, 8]])

    print("=== 1. A @ B ===")
    print(f"{A @ B}")

    print("\n=== 2. Qo'lda (birinchi element) ===")
    print(f"  1*5 + 2*7 = {1*5 + 2*7} (qator × ustun)")

    print("\n=== 3. matmul (bir xil) ===")
    print(f"{np.matmul(A, B)}")

    print("\n=== 4. Tartib muhim ===")
    print(f"  A @ B:\n{A @ B}")
    print(f"  B @ A:\n{B @ A} (BOSHQA!)")
    print("  ⭐ Matritsa ko'paytmasi — qator × ustun")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. A @ B ===
[[19 22]
 [43 50]]

=== 2. Qo'lda (birinchi element) ===
  1*5 + 2*7 = 19 (qator × ustun)

=== 3. matmul (bir xil) ===
[[19 22]
 [43 50]]

=== 4. Tartib muhim ===
  A @ B:
[[19 22]
 [43 50]]
  B @ A:
[[23 34]
 [31 46]] (BOSHQA!)
  ⭐ Matritsa ko'paytmasi — qator × ustun

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Element-wise vs matritsa

python

"""Element-wise vs matritsa: muhim farq (real numpy)."""

import numpy as np


def main() -> None:
    A = np.array([[1, 2], [3, 4]])
    B = np.array([[5, 6], [7, 8]])

    print("=== 1. Element-wise (*) ===")
    print(f"{A * B} (mos element)")

    print("\n=== 2. Matritsa (@) ===")
    print(f"{A @ B} (qator × ustun)")

    print("\n=== 3. Butunlay boshqa ===")
    print("  * — [[5 12] [21 32]] · @ — [[19 22] [43 50]]")

    print("\n=== 4. Xulosa ===")
    print("  * mos element · @ qator × ustun")
    print("  ⭐ * va @ — BUTUNLAY BOSHQA amal")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Element-wise (*) ===
[[ 5 12]
 [21 32]] (mos element)

=== 2. Matritsa (@) ===
[[19 22]
 [43 50]] (qator × ustun)

=== 3. Butunlay boshqa ===
  * — [[5 12] [21 32]] · @ — [[19 22] [43 50]]

=== 4. Xulosa ===
  * mos element · @ qator × ustun
  ⭐ * va @ — BUTUNLAY BOSHQA amal

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Amaliy: ML bashorat

python

"""Amaliy: chiziqli model bashorat (real numpy)."""

import numpy as np


def main() -> None:
    # 3 namuna × 2 xususiyat
    X = np.array([[1., 2.], [3., 4.], [5., 6.]])
    w = np.array([0.5, 1.5])   # vaznlar
    b = 1.0                      # bias

    print("=== 1. Shakllar ===")
    print(f"  X: {X.shape}, w: {w.shape}")

    print("\n=== 2. Bashorat (X @ w + b) ===")
    y = X @ w + b
    print(f"  y: {y}")

    print("\n=== 3. Qo'lda (birinchi namuna) ===")
    print(f"  1*0.5 + 2*1.5 + 1 = {1*0.5 + 2*1.5 + 1}")

    print("\n=== 4. Shakl qoidasi ===")
    print(f"  (3,2) @ (2,) = (3,) — ichki 2 mos")
    print("  ⭐ ML — matritsa ko'paytmasi (y = X @ w + b)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Shakllar ===
  X: (3, 2), w: (2,)

=== 2. Bashorat (X @ w + b) ===
  y: [ 4.5  8.5 12.5]

=== 3. Qo'lda (birinchi namuna) ===
  1*0.5 + 2*1.5 + 1 = 4.5

=== 4. Shakl qoidasi ===
  (3,2) @ (2,) = (3,) — ichki 2 mos
  ⭐ ML — matritsa ko'paytmasi (y = X @ w + b)

Nima ko'rsatdi: 2.8-bo'lim.

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

Noto'g'ri fikr	To'g'risi
"* va @ bir xil"	Butunlay boshqa (element vs matritsa)
"dot — massiv"	Bitta son (vektor uchun)
"@ har shaklda"	Ichki o'lcham mos (shakl qoidasi)
"A @ B = B @ A"	Tartib muhim (kommutativ emas)
"transpose keraksiz"	Shakl mos qilish
"ML — element-wise"	Matritsa ko'paytmasi (@)
"dot va matmul boshqa"	2D'da bir xil (@)
"shakl muhim emas"	Ichki mos (aks holda xato)

6. Keng tarqalgan xatolar va yechimlari

1. * vs @

python

X * w   # element-wise (ML uchun xato)                       # ⚠️
X @ w   # matritsa (ML — bashorat)                            # ✅

2. Shakl mos emas

python

np.array([[1,2,3]]) @ np.array([[1,2,3]])   # xato (1,3)@(1,3) # ⚠️
A @ A.T   # shakl mos (.T)                                     # ✅

3. Tartib

python

A @ B   # ≠ B @ A (kommutativ emas)                          # ⚠️
# tartibni to'g'ri saqla                                       # ✅

4. dot massiv deb

python

np.dot(a, b)   # bitta son (vektor uchun)                    # ⚠️
a * b   # massiv (element-wise)                                # ✅

5. transpose unutish

python

X @ X   # xato (shakl mos emas)                              # ⚠️
X.T @ X   # shakl mos (n,m)@(m,n)                              # ✅

6. 1D vs 2D

python

# vektor (3,) yoki (3,1) — matritsada farq                   # ⚠️
# shaklni aniq belgila                                         # ✅

7. Ichki o'lcham

python

(2,3) @ (2,3)   # xato (ichki 3≠2)                           # ⚠️
(2,3) @ (3,4)   # OK (ichki 3=3, natija (2,4))                # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

2.5-dars (o'tilgan): Vektorlashtirish (element-wise *)
2.7-dars (o'tilgan): Transpose (.T)
3-qism: Matematika (chuqur chiziqli algebra)
20-qism: ML (chiziqli regressiya — X @ w)
22-qism: Deep Learning (neyron qatlamlar — matritsa ko'paytmasi)

8. Eng yaxshi amaliyotlar

@ — matritsa ko'paytmasi (ML).
* — element-wise (matritsa emas!).
np.dot — skalyar ko'paytma (vektor → son).
Shakl qoidasi — ichki mos ((m,n)@(n,p)).
.T — shakl mos qilish.
Tartib muhim (A @ B ≠ B @ A).
ML formula — y = X @ w + b.
Chiziqli algebra — ML matematikasi.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python

1.  # dot nima?
2.  # dot natijasi (vektor)?
3.  # @ nima?
4.  # @ natijasi?
5.  # * va @ farqi?
6.  # A @ B = B @ A?
7.  # shakl qoidasi?
8.  # (2,3)@(3,4)?
9.  # (2,3)@(2,3)?
10. # transpose nima uchun?
11. # ML formula?
12. # nega chiziqli algebra muhim?

Javoblar

Skalyar ko'paytma (mos ko'paytma yig'indisi)
Bitta son
Matritsa ko'paytmasi (qator×ustun)
Matritsa
- element-wise, @ matritsa (boshqa)
Yo'q (tartib muhim)
Ichki mos ((m,n)@(n,p)=(m,p))
OK (2,4) — ichki 3=3
Xato (ichki 3≠2)
Shakl mos qilish
y = X @ w + b
ML/DL matematik asosi (matritsa ko'paytmasi)

Vazifa 2: Xatolarni tuzating

python

1.  X * w   # ML bashorat

2.  (2,3) @ (2,3)   # ichki mos emas

3.  X @ X   # shakl mos emas

4.  np.dot(a, b)   # massiv kutish

5.  B @ A   # A @ B kutilgan

Javoblar

python

1.  X @ w   # matritsa

2.  (2,3) @ (3,4)   # ichki mos

3.  X.T @ X   # transpose

4.  a * b   # element-wise (massiv)

5.  A @ B   # tartib muhim

Vazifa 3: dot

Modellang:

Vektor
Mos ko'paytma
Yig'indi
Bitta son

Vazifa 4: @

Modellang:

Matritsa
Qator × ustun
ML
Tartib

Vazifa 5: * vs @

Modellang:

Element-wise
Matritsa
Farq
Chalkash

Vazifa 6: Shakl

Modellang:

Ichki mos
Tashqi natija
Xato
transpose

Vazifa 7: O'ylash

NumPy'da A * B (element-wise) va A @ B (matritsa ko'paytmasi) butunlay boshqa amallar, lekin ikkalasi ham "ikki matritsani ko'paytirish" deb tuyuladi. Nima uchun bu farq ML uchun hayotiy muhim (bittasi to'g'ri, ikkinchisi jim noto'g'ri natija beradi), va nega yangi boshlovchi buni chalkashtirishi juda oson?

Javob

Qisqa javob: A * B (element-wise) va A @ B (matritsa) butunlay boshqa — ML uchun hayotiy muhim, chunki: (1) turli natija — * mos element (A[i,j]*B[i,j]), @ qator×ustun (skalyar ko'paytmalar); natija butunlay boshqa ([[5,12],[21,32]] vs [[19,22],[43,50]]); (2) ML @ ga tayanadi — chiziqli model y = X @ w (matritsa — har namuna uchun xususiyatlar × vaznlar yig'indisi; bashorat); X * w (element-wise) — noto'g'ri (yig'indi yo'q — har xususiyat alohida, model buziladi); (3) jim xato — * va @ ikkalasi ham ishlaydi (xato bermaydi — agar shakl mos bo'lsa); lekin * noto'g'ri natija (jim — model o'rganmaydi, sabab noaniq; soatlab debug); shakl mos bo'lsa ogohlantirish yo'q (jim buziladi). "Nega chalkash oson": (a) ikkalasi 'ko'paytirish' — * va @ — "ikki matritsa ko'paytirish" deb tuyuladi (nom bir xil — chalkash); (b) * tanish — Python/NumPy'da * odatdagi ko'paytirish (sonlar, element-wise — 2.5); yangi boshlovchi * deb yozadi (matritsa uchun ham — xato); (c) @ yangi — @ operator kam tanish (matritsa maxsus — unutiladi); (d) shakl mos — ba'zan * va @ ikkalasi shakl mos (xato bermaydi — qaysi to'g'ri bilinmaydi); (e) matematika — matritsa ko'paytmasi (qator×ustun) intuitiv emas (element-wise oddiy — ko'proq kutiladi). Oldini olish: (1) @ matritsa, * element-wise (esla — ML @); (2) shakl tekshir (X @ w — (m,n)@(n,) = (m,) bashorat; X * w — element-wise, boshqa shakl); (3) formulani bil (y = X @ w + b — @); (4) natija tekshir (kichik misolda qo'lda — @ qator×ustun-mi); (5) ML kutubxona (sklearn — ichda @; qo'lda yozganda @). Saboqlar: */@ butunlay boshqa (element vs matritsa); ML @ (model — matritsa); jim xato (* noto'g'ri, ogohlantirish yo'q); chalkash oson (nom bir xil, * tanish, @ yangi). To'g'ri: @ matritsa (ML), * element-wise (masshtablash); shakl/natija tekshir. Muvozanat: * (element-wise — masshtablash, oddiy) + @ (matritsa — model) — ikkalasi kerak, lekin joyida (ML model @). Bu ML'ning eng ko'p jim xatosi (soatlab debug — * o'rniga @); ehtiyot (formula, shakl, natija).

1. Nega turli natija

* mos element (A[i,j]*B[i,j])
@ qator×ustun (skalyar ko'paytmalar)
Butunlay boshqa ([[5,12]] vs [[19,22]])

2. Nega ML uchun muhim

ML @ ga tayanadi (y = X @ w — yig'indi)
X * w noto'g'ri (yig'indi yo'q — model buziladi)
Jim xato (shakl mos — ogohlantirish yo'q)

3. Nega chalkash oson

Ikkalasi "ko'paytirish" (nom bir xil)
* tanish (odatdagi), @ yangi
Shakl mos (qaysi to'g'ri bilinmaydi)
Matritsa ko'paytma intuitiv emas

4. Taqqoslash

`A * B`	`A @ B`
Element-wise (mos)	Matritsa (qator×ustun)
Masshtablash	ML model

5. Oldini olish

@ matritsa, * element-wise (esla)
Shakl tekshir (@ natija)
Formula (y = X @ w)
Natija tekshir (qo'lda)

6. Xulosa

*/@ butunlay boshqa (element vs matritsa)
ML @ (model — matritsa ko'paytma)
Jim xato (* noto'g'ri — debug qiyin)
Ehtiyot (formula, shakl, natija)

Nimani mustahkamlaydi: 2.3, 2.7-bo'limlar.

Xulosa

Bu darsda chiziqli algebrani o'rgandik.

Eng muhim uch fikr:

Skalyar va matritsa ko'paytmasi. Skalyar ko'paytma (np.dot) — ikki vektor → bitta son (mos elementlar ko'paytmasi yig'indisi — 1*4+2*5+3*6=32); o'xshashlik. Matritsa ko'paytmasi (@ yoki np.matmul) — qator × ustun (natija[i,j] = i-qator · j-ustun skalyar ko'paytma); ML/DL asosiy amal (X @ w — bashorat); tartib muhim (A @ B ≠ B @ A — kommutativ emas).
Element-wise vs matritsa. A * B (element-wise) va A @ B (matritsa) — BUTUNLAY BOSHQA: * mos element (A[i,j]*B[i,j] — 2.5), @ qator×ustun; turli natija ([[5,12],[21,32]] vs [[19,22],[43,50]]). ML eng ko'p jim xatosi (* o'rniga @ kerak — noto'g'ri natija, ogohlantirish yo'q). Shakl qoida — matritsa ko'paytmasi: ichki o'lchamlar mos ((m,n)@(n,p) — n=n), tashqi natija ((m,p)); (2,3)@(2,3) xato.
ML matematikasi. transpose (.T) — shakl mos qilish (X.T @ X); birlik matritsa (np.eye — matritsa "1", A @ I = A). Chiziqli algebra — ML matematikasi (matritsa ko'paytma — har model; chiziqli regressiya y = X @ w, neyron tarmoq); Data Science poydevori (ML, DL, PCA, tavsiya tizimi). Bu 20-qism (ML), 22-qism (DL) matematik asosi (chuqur — 3-qism). Tuzoqlar: * vs @ (element-wise vs matritsa), shakl mos emas (ichki), tartib (kommutativ emas), transpose unutish.

Keyingi darsda tezlik (sikl vs vektor)ni o'rganamiz: NumPy nega tez ekanini o'lchaymiz (Python sikl bilan taqqoslash) — vektorlashtirishning amaliy foydasi.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!