Data Science va sun'iy intellekt2.6-dars: Broadcasting
Data Science va sun'iy intellekt · NumPy

2.6-dars: Broadcasting

18 daqiqa6/14-dars

2-QISM — NUMPY · 6-dars


1. Kirish va motivatsiya

O'tgan darsda a + b (bir xil shakldagi massivlar) va a * 2 (massiv × son) ni ko'rdik. Lekin agar shakllar turlicha bo'lsa-chi? Masalan, 3×4 matritsaning har qatoriga bir xil 4 ta sonni qo'shmoqchisiz. Sikl yozasizmi? Yo'q — NumPy buni avtomatik qiladi: broadcasting (kengaytirish). Broadcasting — turli shakldagi massivlarni NumPy aqlli tarzda moslashtirib, element-wise amalni bajarishi. Kichik massiv kengaytiriladi (nusxalanmasdan — mantiqan) katta massivga mos keladi. Nega muhim? (1) Kuch — turli o'lchamli ma'lumotni siklsiz birlashtirish (har qatorga o'rtacha qo'shish, har ustunni normallashtirish); (2) Xotira — kichik massiv haqiqatan nusxalanmaydi (tejamli); (3) Data Science asosi — standartlashtirish, markazlashtirish (ML tayyorgarlik) broadcastingga tayanadi. Bu dars broadcastingni chuqur o'rgatadi — NumPy'ning eng chiroyli mexanizmi.

Broadcasting (kengaytirish) — turli shakldagi massivlarni moslashtirib amal: skalyar (massiv × son — 2.5, oddiy holat), qator vektori (2D + 1D — har qatorga), ustun vektori (2D + ustun — har ustunga), qoidalar (o'lchamlar mos yoki 1 bo'lishi kerak), kengaytirish (kichik massiv mantiqan takrorlanadi, xotira tejamli), cheklov (mos kelmasa — xato). Foydalanish: turli o'lcham, standartlashtirish, markazlashtirish. Bu 2.5 (vektorlashtirish), 2.3 (shape) bilan bog'liq. Broadcasting — turli shakl, moslashtirish. Aqlli. Kuchli.

Real vaziyat. Data Scientist 100 talaba × 3 fan (matematika, fizika, ingliz) baholari (100×3 matritsa) ega edi. Har fanni o'rtachasiga nisbatan markazlashtirmoqchi edi (har ustundan o'rtachani ayirish — standartlashtirish). O'rtachalar — 3 ta son ([75, 68, 82]). Sikl yozmadi — natija = baholar - o'rtachalar (broadcasting!): 3 ta o'rtacha har qatorga avtomatik qo'llanildi (100×3 - 3 = har qator - 3). Keyin har talaba bonusi (ustun vektori — 100×1) qo'shdi. Broadcasting turli shaklni aqlli moslashtirdi (siklsiz, xotira tejamli). ML tayyorgarlik (standartlashtirish) broadcastingga tayanadi. Broadcasting — Data Science tayyorgarlik yuragi.

Bu darsda broadcastingni o'rganamiz.

Bu darsda:

  • Broadcasting nima
  • Broadcasting qoidalari
  • Qator va ustun vektori
  • Amaliy: standartlashtirish
  • Xotira (kengaytirish)
  • Broadcasting amaliyoti
  • Broadcasting tuzoqlari
  • Amaliy: broadcasting modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi.


2. Nazariya — chuqur tushuntirish

2.1. Broadcasting nima

Turli shakl — avtomatik moslashish:

python
import numpy as np

# Oddiy: massiv × son (skalyar broadcasting)
a = np.array([1, 2, 3])
a + 10       # [11 12 13] (10 har elementga "kengaydi")

# 2D + 1D: har qatorga
b = np.array([[1, 2, 3], [4, 5, 6]])   # 2×3
v = np.array([10, 20, 30])              # 3
b + v        # [[11 22 33] [14 25 36]] (v har qatorga)

Broadcasting nima — turli shakldagi massivlar avtomatik moslashish: kichik massiv kengaytiriladi (katta massivga mos — har qatorga/ustunga takror). Skalyar (a + 10 — 10 har elementga) — oddiy holat. 2D + 1D (b + v — v har qatorga qo'shiladi). Sabab: turli o'lchamli ma'lumotni siklsiz birlashtirish (har qatorga bir xil vektor — sikl kerak emas); NumPy avtomatik kengaytiradi (kichik massiv — katta o'lchamga moslashadi). "Broadcasting" = eshittirish (kichik massiv katta o'lchamga "eshittiriladi"). Broadcasting — turli shakl avtomatik moslashish. Aqlli. Siklsiz.

2.2. Broadcasting qoidalari

Broadcasting qoidalari — qachon moslashadi:

BROADCASTING QOIDASI (o'ngdan chapga solishtir):
   Har o'lcham uchun:
      1. Bir xil bo'lsa → OK
      2. Bittasi 1 bo'lsa → kengaytiriladi (OK)
      3. Aks holda → XATO (mos kelmaydi)

   MISOL:
      (2, 3) + (3,)    → (2, 3) OK (3 mos)
      (2, 3) + (2, 1)  → (2, 3) OK (1 kengayadi)
      (2, 3) + (2,)    → XATO (3 va 2 mos emas)

Sabab: broadcasting xavfsiz bo'lishi kerak (tasodifiy mos kelish emas — aniq qoida); o'ngdan chapga solishtiradi (oxirgi o'lcham — birinchi); har o'lcham bir xil (mos) yoki bittasi 1 (kengaytiriladi — takror); aks holda xato (mos emas — jim xato oldini). (2,3)+(3,) — 3 mos (har qatorga); (2,3)+(2,1) — 1 kengayadi (har ustunga); (2,3)+(2,) — xato (3≠2). Qoidalar — bir xil yoki 1 (o'ngdan). Xavfsiz. Aniq.

2.3. Qator va ustun vektori

Qator (har qatorga) vs ustun (har ustunga):

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

# QATOR vektori (3,) — har qatorga
qator = np.array([10, 20, 30])
b + qator     # [[11 22 33] [14 25 36]]

# USTUN vektori (2,1) — har ustunga
ustun = np.array([[100], [200]])       # 2×1
b + ustun     # [[101 102 103] [204 205 206]]

Qator va ustun vektori — yo'nalish: qator vektori (3,) — har qatorga qo'shiladi (b + qator — bir xil vektor har qatorda); ustun vektori (2, 1) — har ustunga (b + ustun — bir xil qiymat har ustunda). Sabab: ma'lumotni turli yo'nalishda o'zgartirish (har fan o'rtachasi — ustun bo'yicha, qator vektori; har talaba bonusi — qator bo'yicha, ustun vektori); shakl yo'nalishni belgilaydi ((3,) qator, (2,1) ustun). Ustun uchun (n, 1) shakl kerak (reshape(-1, 1) — 2.7). Qator/ustun vektori — yo'nalish (qator (3,), ustun (n,1)). Yo'nalish muhim.

2.4. Amaliy: standartlashtirish

Broadcasting eng ko'p ishlatiladigan joy:

python
data = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]])

# Markazlashtirish: har ustundan o'rtachani ayirish
ortacha = data.mean(axis=0)    # [4. 5. 6.] (ustun o'rtachalari)
data - ortacha                  # broadcasting (har qatordan)

# Standartlashtirish: (x - o'rtacha) / std
std = data.std(axis=0)
(data - ortacha) / std          # z-score (ML tayyorgarlik)

Amaliy: standartlashtirish — broadcasting eng ko'p joyi: markazlashtirish (data - ortacha — har ustundan o'rtachani ayirish; o'rtacha (3,) har qatorga broadcast), standartlashtirish ((data - ortacha) / std — z-score: o'rtacha 0, std 1). Sabab: ML standartlashtirilgan ma'lumotni talab qiladi (xususiyatlar bir o'lchovda — 20-qism); markazlashtirish/standartlashtirish broadcastingga tayanadi (o'rtacha/std vektori har qatorga — siklsiz). axis=0 (ustun bo'yicha — 2.8). Bu Data Science tayyorgarlik asosi (har ML loyihada). Standartlashtirish — broadcasting amaliyoti (markazlashtirish, z-score). ML tayyorgarlik.

2.5. Xotira (kengaytirish)

Xotira (kengaytirish) — broadcasting haqiqatan nusxalamaydi: b + v da v jismonan takrorlanmaydi (100×3 uchun v ni 100 marta nusxalamaydi — xotira isrof bo'lar edi); NumPy mantiqan kengaytiradi (bir xil v ni qayta-qayta o'qiydi — xotira tejamli). Sabab: agar broadcasting jismonan nusxalasa (kichik massivni katta o'lchamga) — xotira isrof (million qator uchun vektorni million marta — behuda); NumPy aqlli (mantiqan kengaytiradi — bir nusxa, qayta o'qish). Bu broadcastingni tejamli qiladi (tez ham — kam xotira). "Mantiqan kengaytirish" — jismonan emas (bir nusxa, ko'p marta o'qiladi). Xotira — kengaytirish mantiqan (nusxalamaydi). Tejamli. Aqlli.

2.6. Broadcasting amaliyoti

Broadcasting amaliyoti: skalyar (a * 2 — oddiy); qator vektori (b + v — har qatorga, (n,) shakl); ustun vektori (b + u — har ustunga, (n, 1) shakl — reshape(-1, 1)); standartlashtirish ((data - ortacha) / std — z-score); qoida tekshir (o'lchamlar bir xil yoki 1 — mos kelish); axis (o'rtacha/std yo'nalishi — 2.8); shakl anglash (qator vs ustun — yo'nalish). Tuzoqlar: shakl mos emas (xato — qoida tekshir), qator vs ustun chalkash ((n,) vs (n,1)), tasodifiy broadcast (kutilmagan mos kelish — natija noto'g'ri). Amaliyot — skalyar, qator/ustun vektori, standartlashtirish. Yo'nalish. Qoida.

2.7. Broadcasting tuzoqlari

Broadcasting asosiy tuzoqlari: shakl mos emas ((2,3)+(2,) — 3≠2, xato; qoida: o'ngdan bir xil yoki 1); qator vs ustun chalkash ((3,) har qatorga, (3,1) har ustunga — yo'nalish farqli, natija boshqacha); tasodifiy broadcast ((3,1)+(1,3) = (3,3) — kutilmagan kengaytirish, ikkalasi kengayadi; ehtiyot); ustun uchun shakl ((n,) ustun emas — (n,1) kerak, reshape(-1,1)); axis chalkash (axis=0 ustun, axis=1 qator — 2.8; noto'g'ri o'rtacha); jismonan nusxa deb (broadcasting nusxalamaydi — mantiqan; xotira tejamli, lekin ba'zan np.tile kerak). Sabab: broadcasting kuchli lekin nozik (shakl, yo'nalish — jim xato yoki noto'g'ri natija). Yechim: qoida tekshir (shape), yo'nalish angla (qator/ustun), axis to'g'ri. Tuzoqlar — shakl, yo'nalish, tasodifiy broadcast.

2.8. Broadcasting — aqlli moslashish

Broadcasting asosiy g'oyasi — aqlli moslashish: turli shakldagi massivlarni NumPy avtomatik moslashtiradi (kichik massiv kengaytiriladi — katta o'lchamga mos, element-wise amal); sikl kerak emas (har qatorga/ustunga — avtomatik). Qoida: o'ngdan chapga, har o'lcham bir xil yoki bittasi 1 (kengayadi), aks holda xato (xavfsiz — tasodifiy mos emas). Xotira tejamli (jismonan nusxalamaydi — mantiqan kengaytiradi, bir nusxa qayta o'qiydi). Data Science'da tayyorgarlik asosi (standartlashtirish, markazlashtirish — z-score; har ustundan o'rtacha ayirish — broadcasting; ML talab). Bu 2.5 (vektorlashtirish) davomi (skalyar broadcasting — oddiy holat) va butun ML tayyorgarlik uchun. Broadcasting — aqlli moslashish (turli shakl, siklsiz, tejamli). NumPy chiroyi. Data Science tayyorgarlik yuragi.


3. Tez ma'lumotnoma

python
import numpy as np
b = np.array([[1, 2, 3], [4, 5, 6]])   # 2×3

# SKALYAR (oddiy):
b + 10       # har elementga

# QATOR VEKTORI (n,) — har qatorga:
b + np.array([10, 20, 30])   # (3,) har qatorga

# USTUN VEKTORI (n,1) — har ustunga:
b + np.array([[100], [200]])  # (2,1) har ustunga

# QOIDA (o'ngdan chapga):
#   bir xil → OK · bittasi 1 → kengayadi · aks holda XATO
#   (2,3)+(3,) OK · (2,3)+(2,1) OK · (2,3)+(2,) XATO

# STANDARTLASHTIRISH (ML tayyorgarlik):
ortacha = data.mean(axis=0)   # ustun o'rtachalari
std = data.std(axis=0)
z = (data - ortacha) / std     # z-score (broadcasting)

# USTUN VEKTORI YASASH:
v.reshape(-1, 1)   # (n,) → (n,1)

QOIDA: shakl mos (bir xil yoki 1) · qator (n,) · ustun (n,1)

Broadcasting xulosasi

Broadcasting — aqlli moslashish (turli shakl, siklsiz)
Qoida — o'ngdan, bir xil yoki 1 (aks holda xato)
Qator vektori (n,) — har qatorga · ustun (n,1) — har ustunga
Xotira — mantiqan kengayadi (jismonan nusxalamaydi, tejamli)
Standartlashtirish — (data - ortacha) / std (ML tayyorgarlik)

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — Broadcasting asoslari

python
"""Broadcasting: turli shakl (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. Skalyar ===")
    a = np.array([1, 2, 3])
    print(f"  a + 10: {a + 10} (10 kengaydi)")

    print("\n=== 2. 2D + qator vektori ===")
    b = np.array([[1, 2, 3], [4, 5, 6]])
    v = np.array([10, 20, 30])
    print(f"  b + v (har qatorga):\n{b + v}")

    print("\n=== 3. Shakllar ===")
    print(f"  b.shape: {b.shape}, v.shape: {v.shape}")

    print("\n=== 4. Tushuntirish ===")
    print("  v (3,) har qatorga kengaydi")
    print("  ⭐ Broadcasting — aqlli moslashish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Skalyar ===
  a + 10: [11 12 13] (10 kengaydi)

=== 2. 2D + qator vektori ===
  b + v (har qatorga):
[[11 22 33]
 [14 25 36]]

=== 3. Shakllar ===
  b.shape: (2, 3), v.shape: (3,)

=== 4. Tushuntirish ===
  v (3,) har qatorga kengaydi
  ⭐ Broadcasting — aqlli moslashish

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Qator va ustun vektori

python
"""Qator va ustun vektori (real numpy)."""

import numpy as np


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

    print("=== 1. Qator vektori (har qatorga) ===")
    qator = np.array([10, 20, 30])
    print(f"  b + qator:\n{b + qator}")

    print("\n=== 2. Ustun vektori (har ustunga) ===")
    ustun = np.array([[100], [200]])
    print(f"  b + ustun:\n{b + ustun}")

    print("\n=== 3. Ustun vektori yasash ===")
    v = np.array([100, 200])
    print(f"  v.reshape(-1, 1):\n{v.reshape(-1, 1)}")

    print("\n=== 4. Tushuntirish ===")
    print("  qator (3,) — har qatorga · ustun (2,1) — har ustunga")
    print("  ⭐ Yo'nalish — shakl belgilaydi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Qator vektori (har qatorga) ===
  b + qator:
[[11 22 33]
 [14 25 36]]

=== 2. Ustun vektori (har ustunga) ===
  b + ustun:
[[101 102 103]
 [204 205 206]]

=== 3. Ustun vektori yasash ===
  v.reshape(-1, 1):
[[100]
 [200]]

=== 4. Tushuntirish ===
  qator (3,) — har qatorga · ustun (2,1) — har ustunga
  ⭐ Yo'nalish — shakl belgilaydi

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Standartlashtirish

python
"""Standartlashtirish: z-score (real numpy)."""

import numpy as np


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

    print("=== 1. Ustun o'rtachalari ===")
    ortacha = data.mean(axis=0)
    print(f"  o'rtacha: {ortacha}")

    print("\n=== 2. Markazlashtirish ===")
    print(f"  data - o'rtacha:\n{data - ortacha}")

    print("\n=== 3. Standartlashtirish (z-score) ===")
    std = data.std(axis=0)
    z = np.round((data - ortacha) / std, 2)
    print(f"  z-score:\n{z}")

    print("\n=== 4. Natija ===")
    print(f"  z o'rtacha: {np.round(z.mean(axis=0), 2)} (~0)")
    print("  ⭐ Standartlashtirish — broadcasting (ML tayyorgarlik)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Ustun o'rtachalari ===
  o'rtacha: [4. 5. 6.]

=== 2. Markazlashtirish ===
  data - o'rtacha:
[[-3. -3. -3.]
 [ 0.  0.  0.]
 [ 3.  3.  3.]]

=== 3. Standartlashtirish (z-score) ===
  z-score:
[[-1.22 -1.22 -1.22]
 [ 0.    0.    0.  ]
 [ 1.22  1.22  1.22]]

=== 4. Natija ===
  z o'rtacha: [0. 0. 0.] (~0)
  ⭐ Standartlashtirish — broadcasting (ML tayyorgarlik)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Broadcasting qoidalari

python
"""Broadcasting qoidalari: mos kelish (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. (2,3) + (3,) → OK ===")
    a = np.zeros((2, 3))
    b = np.array([1, 2, 3])
    print(f"  natija shakli: {(a + b).shape}")

    print("\n=== 2. (2,3) + (2,1) → OK ===")
    c = np.array([[10], [20]])
    print(f"  natija shakli: {(a + c).shape}")

    print("\n=== 3. (3,1) + (1,3) → (3,3) ===")
    d = np.array([[1], [2], [3]])
    e = np.array([[10, 20, 30]])
    print(f"  natija shakli: {(d + e).shape} (ikkalasi kengaydi)")

    print("\n=== 4. Qoida ===")
    print("  o'ngdan: bir xil yoki 1 → OK, aks holda xato")
    print("  ⭐ Broadcasting qoidasi — xavfsiz moslashish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. (2,3) + (3,) → OK ===
  natija shakli: (2, 3)

=== 2. (2,3) + (2,1) → OK ===
  natija shakli: (2, 3)

=== 3. (3,1) + (1,3) → (3,3) ===
  natija shakli: (3, 3) (ikkalasi kengaydi)

=== 4. Qoida ===
  o'ngdan: bir xil yoki 1 → OK, aks holda xato
  ⭐ Broadcasting qoidasi — xavfsiz moslashish

Nima ko'rsatdi: 2.2-bo'lim.


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

Noto'g'ri fikr To'g'risi
"turli shakl — doim xato" Broadcasting (moslashadi)
"broadcasting nusxalaydi" Mantiqan kengayadi (tejamli)
"har shakl mos keladi" Qoida (bir xil yoki 1)
"(n,) — ustun vektori" Qator (ustun — (n,1))
"sikl kerak (har qatorga)" Broadcasting (siklsiz)
"axis muhim emas" axis=0 ustun, axis=1 qator
"broadcasting sekin" Tejamli (nusxalamaydi)
"shaklni bilmasa ham OK" Yo'nalish muhim

6. Keng tarqalgan xatolar va yechimlari

1. Shakl mos emas

python
np.zeros((2,3)) + np.array([1,2])   # xato (3≠2)             # ⚠️
np.zeros((2,3)) + np.array([1,2,3]) # OK (3 mos)              # ✅

2. Qator vs ustun

python
b + np.array([1, 2])   # (2,) har qatorga (agar 2 ustun)     # ⚠️
b + np.array([[1],[2]])   # (2,1) har ustunga                 # ✅

3. Ustun vektori shakli

python
v   # (n,) — qator (ustun emas)                              # ⚠️
v.reshape(-1, 1)   # (n,1) — ustun                            # ✅

4. axis chalkash

python
data.mean(axis=1)   # qator o'rtachalari (ustun emas)        # ⚠️
data.mean(axis=0)   # ustun o'rtachalari (standartlashtirish) # ✅

5. Tasodifiy broadcast

python
d + e   # (3,1)+(1,3) = (3,3) (kutilmagan!)                  # ⚠️
# shakllarni tekshir (mos kelish)                             # ✅

6. std=0 (bo'lish)

python
(data - ortacha) / std   # std=0 bo'lsa xato (0 ga bo'lish)  # ⚠️
# std=0 ustunlarni tekshir (o'zgarmas)                        # ✅

7. Jismonan nusxa deb

python
# broadcasting nusxa deb o'ylash (xotira)                     # ⚠️
# mantiqan kengayadi (tejamli)                                 # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 2.5-dars (o'tilgan): Vektorlashtirish (skalyar broadcasting)
  • 2.7-dars: Reshape (ustun vektori — (n,1))
  • 2.8-dars: Agregatsiya (axis — o'rtacha)
  • 6-qism: Tozalash (standartlashtirish)
  • 20-qism: ML (xususiyat masshtablash — z-score)

8. Eng yaxshi amaliyotlar

  1. Shakl tekshir (qoida — bir xil yoki 1).

  2. Qator (n,) — har qatorga, ustun (n,1) — har ustunga.

  3. reshape(-1, 1) — ustun vektori.

  4. axis=0 ustun, axis=1 qator (o'rtacha).

  5. Standartlashtirish — (data - ortacha) / std.

  6. Broadcasting — tejamli (nusxalamaydi).

  7. Tasodifiy broadcast — shakl tekshir.

  8. Broadcasting — aqlli moslashish (siklsiz).


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # broadcasting nima?
2.  # turli shakl — doim xato?
3.  # broadcasting qoidasi?
4.  # (2,3)+(3,)?
5.  # (2,3)+(2,)?
6.  # (n,) qator yoki ustun?
7.  # ustun vektori shakli?
8.  # broadcasting nusxalaydimi?
9.  # axis=0 nima?
10. # standartlashtirish?
11. # z-score o'rtachasi?
12. # nega broadcasting kuchli?
Javoblar
  1. Turli shakl avtomatik moslashish
  2. Yo'q (broadcasting)
  3. O'ngdan: bir xil yoki 1
  4. OK (2,3) — 3 mos
  5. Xato (3≠2)
  6. Qator (ustun — (n,1))
  7. (n, 1)
  8. Yo'q (mantiqan kengayadi)
  9. Ustun bo'yicha (o'rtacha)
  10. (data - ortacha) / std
  11. ~0 (markazlashgan)
  12. Turli shaklni siklsiz birlashtiradi

Vazifa 2: Xatolarni tuzating

python
1.  np.zeros((2,3)) + np.array([1,2])   # xato

2.  v   # ustun vektori sifatida

3.  data.mean(axis=1)   # ustun o'rtacha

4.  # har qatorga sikl bilan qo'shish

5.  d + e   # (3,1)+(1,3) kutilmagan
Javoblar
python
1.  np.array([1,2,3])   # (3,) mos

2.  v.reshape(-1, 1)   # (n,1)

3.  data.mean(axis=0)   # ustun

4.  data + vektor   # broadcasting

5.  shakllarni tekshir (mos kelish)

Vazifa 3: Broadcasting

Modellang:

  1. Skalyar
  2. Qator vektori
  3. Ustun vektori
  4. Moslashish

Vazifa 4: Qoida

Modellang:

  1. Bir xil
  2. Bittasi 1
  3. Xato
  4. O'ngdan

Vazifa 5: Standartlashtirish

Modellang:

  1. Markazlashtirish
  2. z-score
  3. axis
  4. ML tayyorgarlik

Vazifa 6: Xotira

Modellang:

  1. Mantiqan
  2. Nusxalamaydi
  3. Tejamli
  4. Aqlli

Vazifa 7: O'ylash

Broadcasting kichik massivni (masalan (3,) vektor) katta massivga ((1000, 3)) mos keltirganda, uni jismonan 1000 marta nusxalamaydi — mantiqan kengaytiradi. Nima uchun bu "jismonan nusxalamaslik" katta ma'lumot uchun juda muhim, va bu NumPy'ning umumiy falsafasi (tezlik + xotira) bilan qanday bog'liq?

Javob

Qisqa javob: Broadcasting kichik massivni ((3,)) katta massivga ((1000,3)) jismonan nusxalamaydi — mantiqan kengaytiradi (bir nusxa, qayta o'qiydi); bu katta ma'lumot uchun muhim, chunki: (1) xotira tejash — jismonan nusxa (3,) ni 1000 marta takrorlar edi ((1000, 3) — 3000 son o'rniga 3 son; 1000x isrof); million qatorda — million marta vektor (behuda — xotira to'lib ketadi); mantiqan — bir nusxa (3 son, qayta o'qiladi); (2) tezlik — nusxa olish vaqt (3000 son yozish — sekin); mantiqan — yozish yo'q (bor sonni qayta o'qiydi — tez); kam xotira kesh do'st (2.1 — tez o'qish); (3) katta ma'lumot mumkin — jismonan nusxa katta ma'lumotda imkonsiz (xotira yetmaydi — million×million); mantiqan — imkonli (kam xotira). "NumPy falsafasi bilan bog'liq": (a) tezlik + xotira birinchi — NumPy tezlik/xotira uchun yaratilgan (2.1 — nega NumPy); broadcasting bu falsafaga mos (mantiqan — tez, tejamli); (b) behuda ish yo'q — vektorlashtirish (siklsiz — 2.5), view (nusxa yo'q — 2.4 slice), broadcasting (jismonan nusxa yo'q) — umumiy naqsh (kerak bo'lmaganda ishlamaslik — tezlik); (c) aqlli standart — NumPy avtomatik optimallashtiradi (foydalanuvchi o'ylamasdan — mantiqan kengayadi, tez/tejamli); (d) ketma-ket xotira — ndarray uzluksiz 2.1-bob; broadcasting bir vektorni ketma-ket qayta o'qiydi (kesh do'st — tez). Saboqlar: jismonan nusxa isrof (1000x xotira, sekin); mantiqan tejamli (bir nusxa, tez); katta ma'lumot mumkin (kam xotira); NumPy falsafa — tezlik + xotira (behuda ish yo'q — view, broadcasting, vektor). To'g'ri: broadcastingga ishon (tejamli, tez); jismonan nusxa faqat kerak bo'lsa (np.tile — kam). Muvozanat: qulaylik (avtomatik moslashish) + samaradorlik (mantiqan — tejamli) — ikkalasi broadcastingda. NumPy naqsh — kerak bo'lmaganda ishlama (view, broadcast, vektor — tezlik/xotira).

1. Nega jismonan nusxa isrof

  • Xotira — (3,) ni 1000 marta (1000x isrof)
  • Million qator — million marta vektor (to'ladi)
  • Vaqt — nusxa yozish (sekin)

2. Nega mantiqan tejamli

  • Bir nusxa (3 son — qayta o'qiladi)
  • Yozish yo'q (tez)
  • Kesh do'st (kam xotira — 2.1)

3. NumPy falsafa bilan bog'liq

  • Tezlik + xotira birinchi (2.1 — nega NumPy)
  • Behuda ish yo'q (view, broadcast, vektor)
  • Aqlli standart (avtomatik optimal)

4. Umumiy naqsh (kerak bo'lmaganda ishlama)

Mexanizm Tejash
View (2.4) Nusxa yo'q
Vektor (2.5) Sikl yo'q
Broadcast Jismonan nusxa yo'q

5. Saboqlar

  1. Jismonan nusxa isrof (1000x, sekin)
  2. Mantiqan tejamli (bir nusxa)
  3. Katta ma'lumot mumkin (kam xotira)
  4. NumPy falsafa — behuda ish yo'q

6. Xulosa

  1. Jismonan nusxa — isrof (xotira, vaqt)
  2. Mantiqan — tejamli (bir nusxa, tez)
  3. Katta ma'lumot — mumkin (kam xotira)
  4. NumPy naqsh — tezlik + xotira (behuda ish yo'q)

Nimani mustahkamlaydi: 2.5, 2.7-bo'limlar.


Xulosa

Bu darsda broadcastingni o'rgandik.

Eng muhim uch fikr:

  1. Broadcasting va qoidalar. Broadcasting — turli shakldagi massivlar avtomatik moslashish (kichik massiv kengaytiriladi — katta o'lchamga mos, siklsiz); skalyar (a + 10) oddiy holat, 2D + 1D (b + v — har qatorga). Qoida — o'ngdan chapga: har o'lcham bir xil (mos) yoki bittasi 1 (kengayadi), aks holda xato ((2,3)+(3,) OK, (2,3)+(2,) xato); xavfsiz (tasodifiy mos emas).

  2. Qator/ustun va standartlashtirish. Qator vektori (n,) — har qatorga; ustun vektori (n, 1) — har ustunga (reshape(-1, 1)); yo'nalish shakl bilan (qator vs ustun). Standartlashtirish — broadcasting eng ko'p joyi: markazlashtirish (data - ortacha — har ustundan o'rtacha), z-score ((data - ortacha) / std — o'rtacha 0, std 1); axis=0 ustun bo'yicha; ML tayyorgarlik asosi.

  3. Aqlli moslashish. Xotira — broadcasting jismonan nusxalamaydi (mantiqan kengaytiradi — bir nusxa qayta o'qiydi, xotira tejamli; katta ma'lumotda muhim — million marta nusxa isrof bo'lar edi). Broadcasting — aqlli moslashish (turli shakl, siklsiz, tejamli — NumPy chiroyi); Data Science tayyorgarlik yuragi (standartlashtirish, markazlashtirish). NumPy falsafasi — tezlik + xotira (behuda ish yo'q: view nusxalamaydi, vektor siklsiz, broadcast jismonan kengaytirmaydi). Tuzoqlar: shakl mos emas (qoida), qator vs ustun chalkash, axis to'g'ri.

Keyingi darsda shakl o'zgartirish (reshape)ni o'rganamiz: massiv o'lchamini o'zgartirish (1D → 2D, flatten, transpose) — ma'lumotni qayta shakllantirish.

NumPy · 6-dars yakunlandi

2.6-dars: Broadcasting

18 daqvaqt
0belgi
Keyingi dars: 2.7-dars: Shakl o'zgartirish (reshape)
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0