IlmHamroh
Data Science va sun'iy intellekt/NumPy7/14-dars17 daqiqa
Mundarija (22)

2.7-dars: Shakl o'zgartirish (reshape)

2-QISM — NUMPY · 7-dars

1. Kirish va motivatsiya

Massiv ma'lumotni saqlaydi, lekin uning shakli (o'lchami) doim mos kelavermaydi. Bazan 12 ta sonli 1D massivni 3×4 matritsaga aylantirmoqchisiz; bazan 2D matritsani bitta uzun qatorga (flatten); bazan qator/ustunni almashtirasiz (transpose). Bu — shakl o'zgartirish: reshape, flatten, transpose. Ma'lumot o'zgarmaydi — faqat uning tashkil etilishi (qanday qatorlar/ustunlarga bo'linishi) o'zgaradi. Nega muhim? (1) Moslik — ML modellari, funksiyalar aniq shakl talab qiladi (rasm 28×28 → 784 vektor; ustun vektori (n,1)); (2) Broadcasting — ustun vektori yasash (reshape(-1, 1) — 2.6); (3) Ma'lumot tayyorlash — bir shakldan boshqasiga (rasm, matn, jadval). Bu dars shakl o'zgartirishni chuqur o'rgatadi — ma'lumotni qayta shakllantirish.

Shakl o'zgartirish — massiv o'lchamini o'zgartirish (ma'lumot o'zgarmasdan): reshape (yangi shakl — (12,) → (3, 4)), -1 (avtomatik hisobla — reshape(-1, 1)), flatten/ravel (2D → 1D — yassilash), transpose/.T (qator↔ustun almashtirish), newaxis (o'lcham qo'shish), shart (element soni saqlanadi — 3*4=12). Foydalanish: model uchun shakl, ustun vektori, ma'lumot tayyorlash. Bu 2.6 (broadcasting), 2.3 (shape) bilan bog'liq. Reshape — shakl o'zgartirish, element saqlanadi. Qayta shakllantirish.

Real vaziyat. Data Scientist 28×28 pikselli raqam rasmini (784 son) ML modelga bermoqchi edi, lekin model 1D vektor (784,) talab qiladi. rasm.reshape(-1) (yoki flatten) bilan 28×28 → 784 aylantirdi. Boshqa holatda: 1D bashoratlar ((100,)) ni ustun vektorga ((100, 1)) — reshape(-1, 1) (broadcasting/model uchun). Matritsani transpose qildi (data.T — qator↔ustun, tahlil uchun). Ma'lumot o'zgarmadi (784 son o'sha) — faqat shakl (28×28 → 784). Shakl o'zgartirish moslik uchun (model, funksiya talabi). Reshape — ma'lumot tayyorlash asosi.

Bu darsda shakl o'zgartirishni o'rganamiz.

Bu darsda:

  • reshape (yangi shakl)
  • -1 (avtomatik o'lcham)
  • flatten va ravel (yassilash)
  • transpose (qator↔ustun)
  • newaxis (o'lcham qo'shish)
  • Reshape amaliyoti
  • Reshape tuzoqlari
  • Amaliy: shakl modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. reshape (yangi shakl)

O'lchamni o'zgartirish:

python
import numpy as np

a = np.arange(12)          # [0 1 2 ... 11] (12 element)

a.reshape(3, 4)            # 3 qator × 4 ustun
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

a.reshape(4, 3)            # 4 qator × 3 ustun
a.reshape(2, 6)            # 2 qator × 6 ustun

reshape (yangi shakl) — o'lchamini o'zgartirish: a.reshape(3, 4) (12 element → 3 qator × 4 ustun), reshape(4, 3), reshape(2, 6). Sabab: ko'pincha ma'lumot noto'g'ri shaklda (1D lekin 2D kerak; model — aniq shakl); reshape qayta tashkil qiladi (ma'lumot o'sha — faqat bo'linish o'zgaradi). SHART: element soni saqlanadi (3*4=12 — 12 element; reshape(3, 5) = 15 ≠ 12, xato). Ma'lumot o'zgarmaydi (0-11 o'sha — faqat shakl). reshape — yangi shakl (element saqlanadi). Qayta tashkil. Moslik.

2.2. -1 (avtomatik o'lcham)

NumPy o'zi hisoblasin:

python
a = np.arange(12)

a.reshape(3, -1)    # 3 qator, ustun AVTOMATIK (4)
a.reshape(-1, 4)    # ustun 4, qator AVTOMATIK (3)
a.reshape(-1)       # 1D (yassilash — 12,)
a.reshape(-1, 1)    # ustun vektori (12, 1)

# -1 = "qolganini o'zing hisobla"

-1 (avtomatik o'lcham) — NumPy o'zi hisoblaydi: reshape(3, -1) (3 qator, ustun avtomatik — 12/3=4), reshape(-1, 4) (ustun 4, qator avtomatik), reshape(-1) (1D — yassilash), reshape(-1, 1) (ustun vektori — 2.6). Sabab: bir o'lchamni bilmasangiz (element soni o'zgaruvchi — qo'lda hisoblash noqulay); -1 NumPy'ga "qolganini o'zing hisobla" (avtomatik — 12/3=4). Faqat bitta -1 (ikki noma'lum — NumPy hisoblamaydi). reshape(-1, 1) — ustun vektori (eng ko'p ishlatiladi). -1 — avtomatik o'lcham (qolgani). Qulay. Bitta.

2.3. flatten va ravel (yassilash)

2D → 1D:

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

b.flatten()    # [1 2 3 4 5 6] (1D — NUSXA)
b.ravel()      # [1 2 3 4 5 6] (1D — VIEW, tez)
b.reshape(-1)  # [1 2 3 4 5 6] (1D)

# flatten — nusxa · ravel — view (agar mumkin bo'lsa)

flatten va ravel (yassilash) — 2D → 1D: b.flatten() (1D — nusxa), b.ravel() (1D — view, tez), b.reshape(-1) (1D). Sabab: ko'pincha 2D → 1D kerak (rasm 28×28 → 784 vektor — model; matritsa → ro'yxat); yassilash bir uzun qator qiladi (qatorlar ketma-ket). Farq: flatten — nusxa (mustaqil — asl saqlanadi, xavfsiz); ravel — view (asl xotira — tez, lekin o'zgartirsa asl 2.4); reshape(-1) — ravel kabi. Xavfsiz kerak bo'lsa flatten, tez kerak bo'lsa ravel. flatten/ravel — 2D→1D (yassilash). flatten nusxa, ravel view. Yassilash.

2.4. transpose (qator↔ustun)

Almashtirish:

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

b.T              # transpose (3×2)
# [[1 4]
#  [2 5]
#  [3 6]]
b.transpose()    # bir xil (b.T)

b.shape          # (2, 3)
b.T.shape        # (3, 2) — qator↔ustun

transpose (qator↔ustun) — almashtirish: b.T (yoki b.transpose()) — qatorlar ustun bo'ladi, ustunlar qator ((2, 3) → (3, 2)); b[i, j] → b.T[j, i]. Sabab: ba'zan ma'lumot noto'g'ri yo'nalishda (qatorlar ustun bo'lishi kerak — chiziqli algebra, tahlil); transpose ag'daradi (diagonal bo'yicha — qator↔ustun). .T (qisqa), transpose() (to'liq). Shakl teskari ((2,3) → (3,2)). Transpose — view (nusxa emas — tez). transpose — qator↔ustun (.T). Ag'darish. View.

2.5. newaxis (o'lcham qo'shish)

Yangi o'lcham:

python
a = np.array([1, 2, 3])       # (3,)

a[:, np.newaxis]    # (3, 1) — ustun vektori
a[np.newaxis, :]    # (1, 3) — qator vektori
a.reshape(-1, 1)    # (3, 1) — bir xil (ustun)

# newaxis — yangi o'lcham qo'shadi (1)

newaxis (o'lcham qo'shish) — yangi o'lcham: a[:, np.newaxis] ((3,) → (3, 1) — ustun vektori), a[np.newaxis, :] ((1, 3) — qator vektori). Sabab: ba'zan o'lcham qo'shish kerak (1D → 2D — broadcasting/model; ustun vektori — 2.6); newaxis 1 o'lchami qo'shadi ((3,) → (3,1) yoki (1,3)). Bu reshape(-1, 1) bilan bir xil (ustun vektori — ikki usul). newaxis = None (a[:, None] ham ishlaydi). newaxis — o'lcham qo'shish ((3,)→(3,1)). reshape kabi. O'lcham.

2.6. Reshape amaliyoti

Reshape amaliyoti: reshape(r, c) (yangi shakl — element saqlanadi); -1 (avtomatik — reshape(-1, 1) ustun vektori, reshape(3, -1) qolgani); flatten (2D→1D nusxa), ravel (2D→1D view — tez); .T (qator↔ustun — transpose); reshape(-1, 1) (ustun vektori — broadcasting 2.6, model); element soni (saqlanishi — tekshir); newaxis (o'lcham qo'shish). Tuzoqlar: element soni mos emas (reshape(3,5) ≠ 12 — xato), flatten vs ravel (nusxa vs view), transpose ma'lumot o'zgartmaydi (faqat yo'nalish), ikki -1 (xato). Amaliyot — reshape, -1, flatten, transpose. Element saqlanadi. Shakl.

2.7. Reshape tuzoqlari

Reshape asosiy tuzoqlari: element soni mos emas (arange(12).reshape(3, 5) = 15 ≠ 12 — xato; r*c = element soni bo'lishi kerak); ikki -1 (reshape(-1, -1) — xato, NumPy ikki noma'lumni hisoblamaydi; faqat bitta); flatten vs ravel (flatten nusxa — xavfsiz, ravel view — o'zgartirsa asl 2.4); transpose view (b.T view — o'zgartmaydi ma'lumot, faqat ko'rinish; .copy() kerak bo'lsa); reshape ma'lumot o'zgartmaydi (faqat shakl — reshape sonlarni o'zgartmaydi, qayta bo'ladi); 1D vs ustun ((n,) qator emas ustun — reshape(-1,1), 2.6 broadcasting); C-tartib (reshape qatorlar bo'yicha to'ldiradi — 2.1 xotira tartibi; kutilmagan bo'lishi mumkin). Sabab: reshape shaklni o'zgartadi (ma'lumot emas — element saqlanadi; shakl/nusxa-view nozik). Yechim: element soni tekshir, flatten/ravel farqi, -1 bitta. Tuzoqlar — element soni, -1, nusxa-view.

2.8. Reshape — ma'lumotni qayta shakllantirish

Reshape asosiy g'oyasi — ma'lumotni qayta shakllantirish: massiv ma'lumotni saqlaydi, lekin uning shakli (tashkil etilishi — qatorlar/ustunlar) o'zgartiriluvchan; reshape/flatten/transpose ma'lumotni o'zgartmasdan (element o'sha) shaklni qayta tashkil qiladi. Sabab: ma'lumot ko'pincha noto'g'ri shaklda (model 1D talab, lekin 2D; broadcasting ustun vektori kerak; rasm 28×28 → 784); shakl o'zgartirish moslik uchun. reshape(r, c) (yangi shakl — element saqlanadi), -1 (avtomatik — ustun vektori reshape(-1,1)), flatten/ravel (2D→1D), .T (qator↔ustun). Data Science'da doim shakl o'zgartirish (rasm — vektor, ustun vektori — broadcasting, transpose — tahlil). Bu 2.3 (shape) davomi va 2.6 (broadcasting — ustun vektori), ML (rasm, matn shakl) uchun. Reshape — ma'lumotni qayta shakllantirish (shakl o'zgaradi, ma'lumot saqlanadi). Moslik. Tayyorlash.

3. Tez ma'lumotnoma

python
import numpy as np
a = np.arange(12)   # 12 element

# RESHAPE (yangi shakl, element saqlanadi):
a.reshape(3, 4)     # 3×4
a.reshape(4, 3)     # 4×3

# -1 (avtomatik o'lcham, faqat bitta):
a.reshape(3, -1)    # 3 qator, ustun avtomatik
a.reshape(-1, 1)    # ustun vektori (12,1) ← broadcasting
a.reshape(-1)       # 1D (yassilash)

# YASSILASH (2D → 1D):
b.flatten()         # nusxa (xavfsiz)
b.ravel()           # view (tez)

# TRANSPOSE (qator↔ustun):
b.T                 # (2,3) → (3,2)

# NEWAXIS (o'lcham qo'shish):
a[:, np.newaxis]    # (3,) → (3,1) ustun

# SHART: element soni saqlanadi (r*c = element)

QOIDA: element saqlanadi · -1 bitta · flatten nusxa, ravel view

Reshape xulosasi

Reshape — ma'lumotni qayta shakllantirish (shakl o'zgaradi, ma'lumot saqlanadi)
reshape(r, c) — yangi shakl (r*c = element soni)
-1 — avtomatik o'lcham (reshape(-1,1) ustun vektori)
flatten (nusxa) / ravel (view) — 2D → 1D
transpose (.T) — qator↔ustun (view)

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — reshape (yangi shakl)

python
"""reshape: yangi shakl (real numpy)."""

import numpy as np


def main() -> None:
    a = np.arange(12)

    print("=== 1. 1D massiv ===")
    print(f"  a: {a} (shakl: {a.shape})")

    print("\n=== 2. 3×4 ===")
    print(f"{a.reshape(3, 4)}")

    print("\n=== 3. 4×3 ===")
    print(f"{a.reshape(4, 3)}")

    print("\n=== 4. Tushuntirish ===")
    print("  ma'lumot o'zgarmaydi (0-11 o'sha)")
    print("  element soni saqlanadi (3*4=12)")
    print("  ⭐ reshape — yangi shakl")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 1D massiv ===
  a: [ 0  1  2  3  4  5  6  7  8  9 10 11] (shakl: (12,))

=== 2. 3×4 ===
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

=== 3. 4×3 ===
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

=== 4. Tushuntirish ===
  ma'lumot o'zgarmaydi (0-11 o'sha)
  element soni saqlanadi (3*4=12)
  ⭐ reshape — yangi shakl

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — -1 (avtomatik o'lcham)

python
"""-1: avtomatik o'lcham (real numpy)."""

import numpy as np


def main() -> None:
    a = np.arange(12)

    print("=== 1. 3 qator, ustun avtomatik ===")
    print(f"  reshape(3, -1) shakli: {a.reshape(3, -1).shape}")

    print("\n=== 2. Ustun 4, qator avtomatik ===")
    print(f"  reshape(-1, 4) shakli: {a.reshape(-1, 4).shape}")

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

    print("\n=== 4. Yassilash ===")
    print(f"  reshape(-1): {a.reshape(-1)} (1D)")
    print("  ⭐ -1 — avtomatik o'lcham (qolganini hisobla)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 3 qator, ustun avtomatik ===
  reshape(3, -1) shakli: (3, 4)

=== 2. Ustun 4, qator avtomatik ===
  reshape(-1, 4) shakli: (3, 4)

=== 3. Ustun vektori ===
  reshape(-1, 1):
[[1]
 [2]
 [3]] (shakl: (3, 1))

=== 4. Yassilash ===
  reshape(-1): [ 0  1  2  3  4  5  6  7  8  9 10 11] (1D)
  ⭐ -1 — avtomatik o'lcham (qolganini hisobla)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — flatten va transpose

python
"""flatten va transpose (real numpy)."""

import numpy as np


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

    print("=== 1. flatten (2D → 1D) ===")
    print(f"  b.flatten(): {b.flatten()}")

    print("\n=== 2. transpose (qator↔ustun) ===")
    print(f"  b.T:\n{b.T}")

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

    print("\n=== 4. flatten vs ravel ===")
    print(f"  ravel (view): {b.ravel()}")
    print("  flatten — nusxa · ravel — view")
    print("  ⭐ Yassilash va transpose")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. flatten (2D → 1D) ===
  b.flatten(): [1 2 3 4 5 6]

=== 2. transpose (qator↔ustun) ===
  b.T:
[[1 4]
 [2 5]
 [3 6]]

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

=== 4. flatten vs ravel ===
  ravel (view): [1 2 3 4 5 6]
  flatten — nusxa · ravel — view
  ⭐ Yassilash va transpose

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

Misol 4 — Amaliy: rasm → vektor

python
"""Amaliy: rasm shaklini o'zgartirish (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. Rasm (4×4 piksel) ===")
    rasm = np.arange(16).reshape(4, 4)
    print(f"  shakl: {rasm.shape}")

    print("\n=== 2. Vektorga (model uchun) ===")
    vektor = rasm.reshape(-1)
    print(f"  vektor: {vektor} (shakl: {vektor.shape})")

    print("\n=== 3. Qaytarish ===")
    qayta = vektor.reshape(4, 4)
    print(f"  qayta shakl: {qayta.shape} (asl)")

    print("\n=== 4. Ustun vektori (bashoratlar) ===")
    bashorat = np.array([1, 0, 1])
    print(f"  reshape(-1, 1) shakl: {bashorat.reshape(-1, 1).shape}")
    print("  ⭐ Reshape — ma'lumot tayyorlash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Rasm (4×4 piksel) ===
  shakl: (4, 4)

=== 2. Vektorga (model uchun) ===
  vektor: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15] (shakl: (16,))

=== 3. Qaytarish ===
  qayta shakl: (4, 4) (asl)

=== 4. Ustun vektori (bashoratlar) ===
  reshape(-1, 1) shakl: (3, 1)
  ⭐ Reshape — ma'lumot tayyorlash

Nima ko'rsatdi: 2.8-bo'lim.

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

Noto'g'ri fikr To'g'risi
"reshape ma'lumot o'zgartiradi" Faqat shakl (ma'lumot saqlanadi)
"har shaklga o'zgartirish mumkin" Element soni saqlanadi (r*c)
"-1 — nol yoki xato" Avtomatik o'lcham (qolgani)
"ikki -1 mumkin" Faqat bitta (bir noma'lum)
"flatten va ravel bir xil" flatten nusxa, ravel view
"transpose ma'lumot o'zgartiradi" Faqat yo'nalish (qator↔ustun)
"(n,) ustun vektori" Qator ((n,1) ustun)
"reshape nusxa" Ko'pincha view

6. Keng tarqalgan xatolar va yechimlari

1. Element soni mos emas

python
np.arange(12).reshape(3, 5)   # xato (15≠12)                 # ⚠️
np.arange(12).reshape(3, 4)   # OK (12)                       # ✅

2. Ikki -1

python
a.reshape(-1, -1)   # xato (ikki noma'lum)                   # ⚠️
a.reshape(-1, 4)    # bitta -1                                 # ✅

3. flatten vs ravel

python
b.ravel()[0] = 9   # asl o'zgaradi (view)                    # ⚠️
b.flatten()   # nusxa (xavfsiz)                                # ✅

4. Ustun vektori

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

5. Element soni bilmaslik

python
data.reshape(10, 10)   # element soni 100 bo'lishi shart     # ⚠️
data.reshape(10, -1)   # -1 avtomatik hisoblaydi              # ✅

6. reshape natijani saqlamaslik

python
a.reshape(3, 4)   # a o'zgarmaydi (yangi qaytaradi)          # ⚠️
b = a.reshape(3, 4)   # natijani saqla                        # ✅

7. transpose ma'lumot deb

python
b.T   # ma'lumot o'zgarmaydi (faqat yo'nalish)               # ⚠️
# transpose — qator↔ustun (sonlar o'sha)                      # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 2.6-dars (o'tilgan): Broadcasting (ustun vektori)
  • 2.3-dars (o'tilgan): Shape
  • 3-qism: Pandas (.values.reshape)
  • 20-qism: ML (X shakli — namunalar × xususiyatlar)
  • 22-qism: Deep Learning (rasm → tensor, batch shakli)

8. Eng yaxshi amaliyotlar

  1. Element soni saqlanadi (r*c = element).

  2. -1 — avtomatik o'lcham (faqat bitta).

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

  4. flatten (nusxa) / ravel (view) — farqni bil.

  5. .T — qator↔ustun (ma'lumot o'zgarmaydi).

  6. Natijani saqla (b = a.reshape(...)).

  7. Shaklni tekshir (model talabi).

  8. Reshape — ma'lumotni qayta shakllantirish.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # reshape nima qiladi?
2.  # ma'lumot o'zgaradimi?
3.  # element soni sharti?
4.  # reshape(3,5) 12 elementga?
5.  # -1 nima?
6.  # ikki -1 mumkinmi?
7.  # reshape(-1,1) nima?
8.  # flatten va ravel farqi?
9.  # transpose nima?
10. # transpose ma'lumot o'zgartiradimi?
11. # newaxis nima?
12. # reshape asl o'zgartiradimi?
Javoblar
  1. Shaklni o'zgartiradi (element saqlanadi)
  2. Yo'q (faqat shakl)
  3. Saqlanadi (r*c = element)
  4. Xato (15≠12)
  5. Avtomatik o'lcham (qolgani)
  6. Yo'q (faqat bitta)
  7. Ustun vektori (n,1)
  8. flatten nusxa, ravel view
  9. Qator↔ustun (.T)
  10. Yo'q (faqat yo'nalish)
  11. O'lcham qo'shish (1)
  12. Yo'q (yangi qaytaradi)

Vazifa 2: Xatolarni tuzating

python
1.  np.arange(12).reshape(3, 5)   # element

2.  a.reshape(-1, -1)   # ikki -1

3.  b.ravel()[0] = 9   # asl o'zgarmaydi deb

4.  v   # ustun vektori sifatida

5.  a.reshape(3, 4)   # asl o'zgaradi deb
Javoblar
python
1.  reshape(3, 4)   # 12 element

2.  reshape(-1, 4)   # bitta -1

3.  b.flatten()   # nusxa

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

5.  b = a.reshape(3, 4)   # natijani saqla

Vazifa 3: reshape

Modellang:

  1. Yangi shakl
  2. Element saqlanadi
  3. Ma'lumot o'sha
  4. Moslik

Vazifa 4: -1

Modellang:

  1. Avtomatik
  2. Ustun vektori
  3. Yassilash
  4. Bitta

Vazifa 5: Yassilash

Modellang:

  1. flatten
  2. ravel
  3. Nusxa vs view
  4. 2D→1D

Vazifa 6: transpose

Modellang:

  1. Qator↔ustun
  2. .T
  3. Yo'nalish
  4. View

Vazifa 7: O'ylash

reshape massiv ma'lumotini o'zgartirmaydi — faqat uning shaklini (qanday qatorlar/ustunlarga bo'linishini). Nima uchun bu "ma'lumot o'sha, faqat ko'rinish o'zgaradi" tushunchasi muhim, va bu NumPy'ning xotira modeli (ketma-ket saqlash — 2.1) bilan qanday bog'liq — nega reshape ko'pincha tez (view)?

Javob

Qisqa javob: reshape ma'lumotni o'zgartmaydi — faqat shaklni (bo'linish); bu muhim, chunki: (1) ma'lumot xavfsiz — reshape sonlarni o'zgartmaydi (0-11 o'sha — faqat 3×4 yoki 4×3 bo'ladi); ma'lumot buzilmaydi (ishonch — reshape zararsiz, faqat ko'rinish); (2) qaytariluvchan — reshape(3,4) keyin reshape(-1) — asl 1D (ma'lumot o'sha — qaytish mumkin); (3) anglash — reshape "ma'lumotni qayta bo'lish" (12 sonni 3×4 yoki 4×3 — bir xil sonlar, boshqa tashkil); "yangi ma'lumot" emas (chalkashmaslik). "NumPy xotira modeli bilan bog'liq (nega tez — view)": (a) ketma-ket saqlash — ndarray xotirada uzluksiz (2.1 — 12 son ketma-ket: 0,1,2,...,11); shakl faqat "qanday o'qish" (3×4 — har 4 tadan qator; 4×3 — har 3 tadan); (b) view — nusxa yo'q — reshape xuddi shu xotirani boshqacha o'qiydi (sonlar ko'chmaydi — faqat "qadam" o'zgaradi: qator uzunligi); ma'lumot bir joyda (view — yangi "oyna", nusxa emas); (c) tez — nusxa olmasa tez (12 son ko'chirish yo'q — faqat shakl metama'lumoti o'zgaradi; bir zumda); katta massivda — juda tez (million son ko'chmaydi); (d) kesh do'st — bir xotira (2.1 — uzluksiz, tez o'qish). Nega ba'zan nusxa (view emas): transpose keyin reshape — xotira tartibi mos kelmasa (C-tartib buziladi) — NumPy nusxa oladi (ketma-ket qilish uchun); lekin oddiy reshape — view (tez). Saboqlar: reshape ma'lumot o'zgartmaydi (faqat shakl — xavfsiz, qaytariluvchan); ketma-ket xotira (shakl — qanday o'qish, sonlar bir joyda); view — nusxa yo'q (tez — sonlar ko'chmaydi); ba'zan nusxa (tartib buzilsa). To'g'ri: reshapega ishon (ma'lumot xavfsiz, tez); shaklni "ko'rinish" deb angla (sonlar o'sha). Muvozanat: qulaylik (istalgan shakl) + tezlik (view — nusxa yo'q) — NumPy xotira modeli (uzluksiz) buni beradi. Bu 2.4 (view) va 2.1 (xotira) bilan bir naqsh (NumPy tezlik/xotira — behuda ish yo'q).

1. Nega "ma'lumot o'sha" muhim

  • Xavfsiz — sonlar o'zgartmaydi (buzilmaydi)
  • Qaytariluvchan (reshape keyin qaytish)
  • Anglash — qayta bo'lish (yangi emas)

2. NumPy xotira modeli (nega tez)

  • Ketma-ket saqlash (2.1 — uzluksiz, 0-11)
  • Shakl — qanday o'qish (3×4 yoki 4×3)
  • View — nusxa yo'q (sonlar bir joyda)

3. Nega tez (view)

  • Nusxa olmaydi (12 son ko'chmaydi)
  • Faqat metama'lumot (shakl o'zgaradi)
  • Kesh do'st (bir xotira — 2.1)

4. Ba'zan nusxa

Holat Natija
Oddiy reshape View (tez)
Transpose keyin (tartib buziladi) Nusxa

5. Saboqlar

  1. Reshape ma'lumot o'zgartmaydi (xavfsiz)
  2. Ketma-ket xotira (shakl — o'qish usuli)
  3. View — nusxa yo'q (tez)
  4. Ba'zan nusxa (tartib)

6. Xulosa

  1. Ma'lumot o'sha (faqat shakl — xavfsiz)
  2. Ketma-ket xotira (shakl — qanday o'qish)
  3. View — tez (sonlar ko'chmaydi)
  4. NumPy naqsh — tezlik/xotira (behuda ish yo'q)

Nimani mustahkamlaydi: 2.7, 2.1-bo'limlar.

Xulosa

Bu darsda shakl o'zgartirishni o'rgandik.

Eng muhim uch fikr:

  1. reshape va -1. reshape — o'lchamni o'zgartirish: a.reshape(3, 4) (12 element → 3×4); ma'lumot o'zgarmaydi (faqat shakl — qayta bo'linish), element soni saqlanadi (3*4=12; reshape(3,5) ≠ 12 xato). -1 — avtomatik o'lcham: reshape(3, -1) (ustun avtomatik — qolgani 12/3=4), reshape(-1, 1) (ustun vektori — broadcasting/model), reshape(-1) (1D); faqat bitta -1.

  2. Yassilash va transpose. flatten/ravel — 2D → 1D (yassilash): flatten nusxa (xavfsiz), ravel view (tez — o'zgartsa asl 2.4). transpose (.T) — qator↔ustun almashtirish ((2,3) → (3,2); ma'lumot o'zgartmaydi — faqat yo'nalish, view). newaxis — o'lcham qo'shish ((3,) → (3,1) ustun; reshape(-1,1) bilan bir xil).

  3. Qayta shakllantirish. Reshape — ma'lumotni qayta shakllantirish: massiv ma'lumotni saqlaydi, shakli o'zgartiriluvchan (reshape/flatten/transpose — ma'lumot o'zgarmasdan, tashkil o'zgaradi); moslik uchun (model 1D talab, broadcasting ustun vektori, rasm 28×28 → 784). NumPy xotira modeli (ketma-ket saqlash — 2.1) reshapeni tez qiladi (view — sonlar ko'chmaydi, faqat "qanday o'qish" o'zgaradi; nusxa yo'q). Tuzoqlar: element soni mos emas, ikki -1, flatten (nusxa) vs ravel (view), transpose ma'lumot o'zgartmaydi.

Keyingi darsda agregatsiya (sum, mean, axis)ni o'rganamiz: massivni jamlash — yig'indi, o'rtacha, min/max, va axis bilan yo'nalish bo'yicha hisob.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
2.7-dars: Shakl o'zgartirish (reshape) — IlmHamroh