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

2.10-dars: Tasodifiy sonlar

2-QISM — NUMPY · 10-dars

1. Kirish va motivatsiya

Data Science'da tasodif hamma joyda: ma'lumotni tasodifiy aralashtirish (train/test bo'lish), tasodifiy namuna olish, simulyatsiya (tanga tashlash, statistik tajriba), ML modellarining tasodifiy boshlang'ich holati. NumPy random moduli buni beradi: rand (0-1 orasi), randint (butun), normal (normal taqsimot), choice (ro'yxatdan tanlash), shuffle (aralashtirish). Lekin bitta muhim tushuncha bor: seed (urug'). Tasodifiy sonlar aslida psevdo-tasodifiy (algoritm hisoblaydi); seed bilan bir xil natijani qayta olish mumkin — bu Data Science uchun shart (tajriba takrorlanuvchi bo'lishi, natija tekshiriluvchi bo'lishi). Nega muhim? (1) Takrorlanuvchanlik — seed bilan bir xil natija (fan asosi); (2) Simulyatsiya — statistik tajribalar, ehtimollik; (3) ML — ma'lumot bo'lish, model init. Bu dars tasodifiy sonlarni chuqur o'rgatadi — takrorlanuvchi tasodif.

Tasodifiy sonlar — NumPy random: seed (urug' — takrorlanuvchi natija, np.random.seed(0)), rand (0-1 orasi tekis), randint (butun oraliq), normal (normal taqsimot — o'rtacha/std), choice (ro'yxatdan tanlash), shuffle (aralashtirish), taqsimotlar (uniform, normal). Foydalanish: simulyatsiya, namuna, ML tayyorgarlik, aralashtirish. Bu 4-qism (statistika), 20-qism (ML) bilan bog'liq. Random — tasodif. seed — takrorlanuvchi. Simulyatsiya.

Real vaziyat. Data Scientist ML modelni o'rgatish uchun 1000 qatorli ma'lumotni train/test ga bo'lmoqchi edi (80% o'rganish, 20% sinov). Tasodifiy bo'lish kerak (tartib ta'sir qilmasin) — np.random.shuffle (aralashtirish). Lekin takrorlanuvchi bo'lish shart edi (ertaga bir xil natija — tajriba tekshiriluvchi); np.random.seed(0) qo'ydi (urug' — har safar bir xil aralashish). Simulyatsiya qildi: 10000 tanga tashlash (np.random.randint(0, 2, 10000)) — Yormi/Bukasi nisbati ~0.5. Normal taqsimot (np.random.normal(75, 10, 1000) — baholar). seed takrorlanuvchanlik berdi (fan asosi — natija qayta olinadi). Random — simulyatsiya va ML asosi; seed — takrorlanuvchanlik sharti.

Bu darsda tasodifiy sonlarni o'rganamiz.

Bu darsda:

  • seed (takrorlanuvchanlik)
  • rand va randint
  • normal (taqsimot)
  • choice va shuffle
  • Simulyatsiya
  • Random amaliyoti
  • Random tuzoqlari
  • Amaliy: tasodif modeli

ℹ Misollar real numpy bilan (deterministik — seed) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. seed (takrorlanuvchanlik)

Bir xil natijani qayta olish:

python
import numpy as np

# seed BO'LMASA — har safar boshqa
np.random.rand(3)    # [0.71 0.42 0.65] (har safar boshqa)

# seed BILAN — bir xil natija
np.random.seed(0)
np.random.rand(3)    # [0.5488 0.7152 0.6028] (DOIM shu)
np.random.seed(0)
np.random.rand(3)    # [0.5488 0.7152 0.6028] (bir xil!)

seed (urug' — takrorlanuvchanlik) — bir xil natijani qayta olish: np.random.seed(0) (urug' o'rnatadi), keyin tasodifiy sonlar doim bir xil (seed(0) → doim [0.5488, ...]). Sabab: tasodifiy sonlar aslida psevdo-tasodifiy (algoritm hisoblaydi — urug'dan boshlab); seed bilan bir xil boshlanish → bir xil natija (takrorlanuvchi). Data Science'da shart (tajriba takrorlanuvchi — ertaga bir xil; natija tekshiriluvchi — boshqalar qayta oladi; fan asosi). seed(0), random_state=0 (sklearn — 20-qism). seed — takrorlanuvchanlik (bir xil natija). Psevdo-tasodif. Fan sharti.

2.2. rand va randint

Tekis tasodif:

python
np.random.seed(0)

np.random.rand(3)          # [0.5488 0.7152 0.6028] (0-1 orasi)
np.random.rand(2, 3)       # 2×3 massiv (0-1)

np.random.randint(1, 7, 5) # [5 6 1 4 4] (1-6 butun — zar)
np.random.randint(0, 2, 4) # [0 1 1 0] (0 yoki 1 — tanga)

np.random.uniform(10, 20, 3)  # [.. .. ..] (10-20 orasi kasr)

rand va randint — tekis tasodif: rand (0-1 orasi kasr — tekis, rand(3) 3 son, rand(2, 3) 2×3), randint (butun oraliq — randint(1, 7, 5) 1-6 orasi 5 son; yuqori chegara kirmaydi — 7 emas), uniform (oraliq kasr — uniform(10, 20, 3)). Sabab: turli tasodifiy kerak (0-1 ehtimollik — rand; zar/tanga butun — randint; oraliq kasr — uniform); "tekis" (uniform — har qiymat teng ehtimol). randint(low, high, size) — high kirmaydi (slice kabi — 2.4). rand/randint — tekis tasodif (rand 0-1, randint butun). Tekis. Oraliq.

2.3. normal (taqsimot)

Normal (gauss) taqsimot:

python
np.random.seed(0)

# normal(o'rtacha, std, size)
np.random.normal(0, 1, 5)      # standart normal (o'rtacha 0, std 1)
np.random.normal(75, 10, 1000) # baholar (o'rtacha 75, std 10)

# ko'p qiymat o'rtacha atrofida (qo'ng'iroq shakli)

normal (taqsimot) — normal (gauss/qo'ng'iroq) taqsimot: np.random.normal(o'rtacha, std, size) — o'rtacha atrofida (normal(0, 1, 5) standart normal, normal(75, 10, 1000) baholar). Sabab: real dunyoda ko'p narsa normal taqsimlangan (bo'y, vazn, baho, xato — o'rtacha atrofida ko'p, chetda kam — qo'ng'iroq shakli); rand (tekis — har qiymat teng) real emas, normal realroq (simulyatsiya). normal(o'rtacha, std, size) — markaz (o'rtacha), tarqoqlik (std — 2.8). Statistika (4-qism) asosi. normal — normal taqsimot (o'rtacha, std). Qo'ng'iroq. Real.

2.4. choice va shuffle

Tanlash va aralashtirish:

python
np.random.seed(0)

# choice — ro'yxatdan tasodifiy tanlash
np.random.choice([10, 20, 30, 40], 2)   # [.. ..] (2 ta)
np.random.choice(["A", "B", "C"], 5)    # 5 ta (takror mumkin)

# shuffle — massivni aralashtirish (JOYIDA)
a = np.array([1, 2, 3, 4, 5])
np.random.shuffle(a)     # a aralashadi (joyida)

# permutation — aralashgan NUSXA
np.random.permutation([1, 2, 3, 4])

choice va shuffle — tanlash va aralashtirish: choice (ro'yxatdan tasodifiy tanlash — choice([10,20,30], 2) 2 ta; takror mumkin, replace=False takrorsiz), shuffle (massivni aralashtiradi — joyida, asl o'zgaradi), permutation (aralashgan nusxa — asl saqlanadi). Sabab: tanlash (tasodifiy namuna — choice; so'rovnoma, test); aralashtirish (tartib ta'sir qilmasin — train/test bo'lish, shuffle; ML). shuffle joyida (asl o'zgaradi), permutation nusxa (asl saqlanadi — xavfsiz). choice/shuffle — tanlash, aralashtirish. Namuna. train/test.

2.5. Simulyatsiya

Simulyatsiya — tasodifiy tajriba: real dunyoni modellash (tasodifiy sonlar bilan — tanga, zar, statistik tajriba); ko'p marta takrorlab ehtimollik/naqsh topish. Misol: 10000 tanga tashlash (randint(0, 2, 10000) — 0/1) → Yormi nisbati ~0.5 (katta sonlar qonuni — 4-qism); 1000 zar (randint(1, 7, 1000)) → o'rtacha ~3.5. Sabab: ba'zan matematik yechish qiyin (murakkab ehtimollik); simulyatsiya taqribiy javob (ko'p tajriba — o'rtacha natija); statistika (4-qism), Monte-Carlo. seed bilan takrorlanuvchi (bir xil tajriba). Simulyatsiya — tasodifiy tajriba (tanga, zar). Ehtimollik. Modellash.

2.6. Random amaliyoti

Random amaliyoti: seed (takrorlanuvchanlik — doim boshda, np.random.seed(0)); rand (0-1 kasr), randint (butun — high kirmaydi), uniform (oraliq kasr); normal (real taqsimot — o'rtacha/std); choice (tanlash — replace=False takrorsiz); shuffle (aralashtirish — joyida, train/test); permutation (aralashgan nusxa — xavfsiz); simulyatsiya (ko'p tajriba — ehtimollik). Tuzoqlar: seed unutish (takrorlanmaydi — tajriba tekshirib bo'lmaydi), randint high (kirmaydi), shuffle joyida (asl o'zgaradi), global seed (eski usul — yangi default_rng afzal). Amaliyot — seed, rand/randint, normal, choice/shuffle. Takrorlanuvchanlik. Tasodif.

2.7. Random tuzoqlari

Random asosiy tuzoqlari: seed unutish (seed yo'q — har safar boshqa natija; tajriba takrorlanmaydi — natija tekshirib bo'lmaydi, fan buziladi); randint high (randint(1, 7) — 1-6, 7 kirmaydi; zar uchun randint(1, 7) to'g'ri, randint(1, 6) xato — 1-5); shuffle joyida (shuffle(a) asl o'zgaradi — nusxa kerak bo'lsa permutation); shuffle qaytarmaydi (b = np.random.shuffle(a) — b None; shuffle joyida, qaytarmaydi); global seed (np.random.seed — global, eski; yangi default_rng — mustaqil generator, afzal); seed joyi (seed bir marta boshda — har amaldan oldin emas; aks holda bir xil takror); normal manfiy (normal manfiy son berishi mumkin — yosh/narx uchun ehtiyot). Sabab: random takrorlanuvchanlik/chegara nozik (seed, high, joyida — jim xato yoki takrorlanmaydi). Yechim: seed doim, high kirmaydi, shuffle joyida. Tuzoqlar — seed, high, joyida.

2.8. Random — takrorlanuvchi tasodif

Random asosiy g'oyasi — takrorlanuvchi tasodif: Data Science'da tasodif kerak (aralashtirish, namuna, simulyatsiya, ML init), lekin takrorlanuvchanlik ham shart (tajriba qayta olinadigan, natija tekshiriluvchi — fan asosi); seed bu ikkisini birlashtiradi (tasodif, lekin bir xil urug'dan — takrorlanuvchi). Tasodifiy sonlar psevdo-tasodifiy (algoritm — urug'dan hisoblaydi; seed bir xil urug' → bir xil natija). rand/randint (tekis), normal (real taqsimot), choice/shuffle (tanlash/aralashtirish), simulyatsiya (ehtimollik). Data Science'da doim (train/test bo'lish — shuffle + seed; simulyatsiya — statistika; model init — random_state). Bu 4-qism (statistika — taqsimot, simulyatsiya), 20-qism (ML — train/test, model) uchun asos. Random — takrorlanuvchi tasodif (seed + tasodif). Takrorlanuvchanlik. Fan asosi.

3. Tez ma'lumotnoma

python
import numpy as np

# SEED (takrorlanuvchanlik — DOIM boshda):
np.random.seed(0)   # bir xil natija (fan sharti)

# TEKIS TASODIF:
np.random.rand(3)          # 0-1 orasi kasr
np.random.rand(2, 3)       # 2×3 massiv
np.random.randint(1, 7, 5) # 1-6 butun (7 KIRMAYDI — zar)
np.random.uniform(10, 20, 3)  # 10-20 orasi kasr

# NORMAL TAQSIMOT (real):
np.random.normal(75, 10, 1000)   # o'rtacha 75, std 10

# TANLASH VA ARALASHTIRISH:
np.random.choice([10, 20, 30], 2)   # ro'yxatdan tanlash
np.random.choice(a, 5, replace=False)  # takrorsiz
np.random.shuffle(a)        # aralashtirish (JOYIDA)
np.random.permutation(a)    # aralashgan NUSXA

QOIDA: seed doim (takrorlanuvchi) · randint high kirmaydi · shuffle joyida

Random xulosasi

Random — takrorlanuvchi tasodif (seed + tasodif)
seed — takrorlanuvchanlik (bir xil natija, fan sharti)
rand (0-1) · randint (butun, high kirmaydi) · normal (real taqsimot)
choice (tanlash) · shuffle (aralashtirish, joyida)
Simulyatsiya — ko'p tajriba (ehtimollik)

4. Batafsil misollar

Misollar real numpy bilan (seed=0 — deterministik) ishlaydi.

Misol 1 — seed (takrorlanuvchanlik)

python
"""seed: takrorlanuvchanlik (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. seed bilan ===")
    np.random.seed(0)
    print(f"  rand(3): {np.round(np.random.rand(3), 4)}")

    print("\n=== 2. Qayta seed(0) — bir xil ===")
    np.random.seed(0)
    print(f"  rand(3): {np.round(np.random.rand(3), 4)}")

    print("\n=== 3. Bir xil natija ===")
    print("  seed(0) → doim [0.5488 0.7152 0.6028]")

    print("\n=== 4. Nega muhim ===")
    print("  tajriba takrorlanuvchi (fan sharti)")
    print("  ⭐ seed — takrorlanuvchanlik")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. seed bilan ===
  rand(3): [0.5488 0.7152 0.6028]

=== 2. Qayta seed(0) — bir xil ===
  rand(3): [0.5488 0.7152 0.6028]

=== 3. Bir xil natija ===
  seed(0) → doim [0.5488 0.7152 0.6028]

=== 4. Nega muhim ===
  tajriba takrorlanuvchi (fan sharti)
  ⭐ seed — takrorlanuvchanlik

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — rand va randint

python
"""rand va randint (real numpy)."""

import numpy as np


def main() -> None:
    np.random.seed(0)

    print("=== 1. rand (0-1) ===")
    print(f"  rand(3): {np.round(np.random.rand(3), 4)}")

    print("\n=== 2. randint (butun) ===")
    np.random.seed(0)
    print(f"  zar (1-6): {np.random.randint(1, 7, 5)}")

    print("\n=== 3. tanga (0/1) ===")
    np.random.seed(0)
    print(f"  tanga: {np.random.randint(0, 2, 8)}")

    print("\n=== 4. uniform (oraliq kasr) ===")
    np.random.seed(0)
    print(f"  uniform(10, 20): {np.round(np.random.uniform(10, 20, 3), 2)}")
    print("  ⭐ rand (0-1), randint (butun, high kirmaydi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. rand (0-1) ===
  rand(3): [0.5488 0.7152 0.6028]

=== 2. randint (butun) ===
  zar (1-6): [5 6 1 4 4]

=== 3. tanga (0/1) ===
  tanga: [0 1 1 0 1 1 1 1]

=== 4. uniform (oraliq kasr) ===
  uniform(10, 20): [15.49 17.15 16.03]
  ⭐ rand (0-1), randint (butun, high kirmaydi)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — normal (taqsimot)

python
"""normal: taqsimot (real numpy)."""

import numpy as np


def main() -> None:
    np.random.seed(0)

    print("=== 1. Standart normal ===")
    print(f"  normal(0, 1, 5): {np.round(np.random.normal(0, 1, 5), 3)}")

    print("\n=== 2. Baholar (o'rtacha 75) ===")
    np.random.seed(0)
    baho = np.random.normal(75, 10, 1000)
    print(f"  o'rtacha: {round(baho.mean(), 1)}, std: {round(baho.std(), 1)}")

    print("\n=== 3. Chegaralar ===")
    print(f"  min: {round(baho.min(), 1)}, max: {round(baho.max(), 1)}")

    print("\n=== 4. Qo'ng'iroq shakli ===")
    print("  ko'p qiymat o'rtacha (75) atrofida")
    print("  ⭐ normal — real taqsimot (o'rtacha, std)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Standart normal ===
  normal(0, 1, 5): [1.764 0.4   0.979 2.241 1.868]

=== 2. Baholar (o'rtacha 75) ===
  o'rtacha: 74.5, std: 9.9

=== 3. Chegaralar ===
  min: 44.5, max: 102.6

=== 4. Qo'ng'iroq shakli ===
  ko'p qiymat o'rtacha (75) atrofida
  ⭐ normal — real taqsimot (o'rtacha, std)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Simulyatsiya (tanga)

python
"""Simulyatsiya: tanga tashlash (real numpy)."""

import numpy as np


def main() -> None:
    np.random.seed(0)

    print("=== 1. 10000 tanga ===")
    tanga = np.random.randint(0, 2, 10000)
    yormi = (tanga == 1).sum()
    print(f"  Yormi: {yormi}, nisbat: {round(yormi / 10000, 3)}")

    print("\n=== 2. Zar (1000 marta) ===")
    np.random.seed(0)
    zar = np.random.randint(1, 7, 1000)
    print(f"  o'rtacha: {round(zar.mean(), 2)} (kutilgan 3.5)")

    print("\n=== 3. choice (tanlash) ===")
    np.random.seed(0)
    print(f"  tanlangan: {np.random.choice([10, 20, 30, 40], 3)}")

    print("\n=== 4. shuffle (aralashtirish) ===")
    np.random.seed(0)
    a = np.arange(1, 6)
    np.random.shuffle(a)
    print(f"  aralashgan: {a}")
    print("  ⭐ Simulyatsiya — ko'p tajriba (ehtimollik)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 10000 tanga ===
  Yormi: 5085, nisbat: 0.508

=== 2. Zar (1000 marta) ===
  o'rtacha: 3.52 (kutilgan 3.5)

=== 3. choice (tanlash) ===
  tanlangan: [10 40 20]

=== 4. shuffle (aralashtirish) ===
  aralashgan: [3 1 2 4 5]
  ⭐ Simulyatsiya — ko'p tajriba (ehtimollik)

Nima ko'rsatdi: 2.5-bo'lim.

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

Noto'g'ri fikr To'g'risi
"tasodif haqiqiy" Psevdo-tasodif (algoritm)
"seed keraksiz" Takrorlanuvchanlik (fan sharti)
"randint high kiradi" Kirmaydi (1,7 → 1-6)
"rand — butun" 0-1 kasr (randint — butun)
"shuffle nusxa qaytaradi" Joyida (None qaytaradi)
"normal — tekis" Qo'ng'iroq (o'rtacha atrofida)
"seed har amaldan oldin" Bir marta boshda
"choice takrorsiz" Takror mumkin (replace=False takrorsiz)

6. Keng tarqalgan xatolar va yechimlari

1. seed unutish

python
np.random.rand(3)   # har safar boshqa (takrorlanmaydi)      # ⚠️
np.random.seed(0); np.random.rand(3)   # takrorlanuvchi       # ✅

2. randint high

python
np.random.randint(1, 6)   # 1-5 (zar uchun xato)             # ⚠️
np.random.randint(1, 7)   # 1-6 (zar — 7 kirmaydi)            # ✅

3. shuffle qaytarish

python
b = np.random.shuffle(a)   # b = None (joyida)               # ⚠️
np.random.shuffle(a)   # a aralashadi (joyida)                # ✅

4. shuffle nusxa kerak

python
np.random.shuffle(a)   # asl o'zgaradi                        # ⚠️
b = np.random.permutation(a)   # nusxa (asl saqlanadi)        # ✅

5. seed joyi

python
for i in range(3): np.random.seed(0); ...   # bir xil takror # ⚠️
np.random.seed(0)   # bir marta boshda                        # ✅

6. choice takror

python
np.random.choice(a, 5)   # takror mumkin                     # ⚠️
np.random.choice(a, 5, replace=False)   # takrorsiz           # ✅

7. normal manfiy

python
np.random.normal(50, 30)   # manfiy bo'lishi mumkin (yosh?)  # ⚠️
# yosh/narx uchun chegara/clip                                 # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 2.8-dars (o'tilgan): Agregatsiya (mean, std — taqsimot tekshirish)
  • 4-qism: Statistika (taqsimotlar, simulyatsiya, Monte-Carlo)
  • 20-qism: ML (train/test bo'lish — shuffle, random_state)
  • 22-qism: Deep Learning (model init — seed, torch.manual_seed)
  • 6-qism: Namuna olish (tasodifiy tanlash)

8. Eng yaxshi amaliyotlar

  1. seed — doim boshda (takrorlanuvchanlik).

  2. randint — high kirmaydi (1,7 → 1-6).

  3. normal — real taqsimot (o'rtacha/std).

  4. shuffle — joyida (nusxa kerak bo'lsa permutation).

  5. choice — replace=False takrorsiz.

  6. Simulyatsiya — ko'p tajriba (ehtimollik).

  7. seed bir marta (har amaldan oldin emas).

  8. Random — takrorlanuvchi tasodif (seed).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # tasodif haqiqiymi?
2.  # seed nima?
3.  # nega seed muhim?
4.  # rand nima?
5.  # randint(1,7) diapazoni?
6.  # high kiradimi?
7.  # normal nima?
8.  # normal vs rand?
9.  # shuffle nima qaytaradi?
10. # shuffle joyida yoki nusxa?
11. # permutation nima?
12. # simulyatsiya nima?
Javoblar
  1. Yo'q (psevdo-tasodif)
  2. Urug' (takrorlanuvchanlik)
  3. Tajriba takrorlanuvchi (fan)
  4. 0-1 orasi kasr
  5. 1-6 (7 kirmaydi)
  6. Yo'q (kirmaydi)
  7. Normal taqsimot (o'rtacha, std)
  8. normal qo'ng'iroq, rand tekis
  9. None (joyida)
  10. Joyida (asl o'zgaradi)
  11. Aralashgan nusxa
  12. Ko'p tajriba (ehtimollik)

Vazifa 2: Xatolarni tuzating

python
1.  np.random.rand(3)   # takrorlanuvchi kerak

2.  np.random.randint(1, 6)   # zar (1-6)

3.  b = np.random.shuffle(a)   # nusxa kutish

4.  # har iteratsiyada seed(0)

5.  np.random.choice(a, 5)   # takrorsiz kerak
Javoblar
python
1.  np.random.seed(0); np.random.rand(3)

2.  np.random.randint(1, 7)   # 7 kirmaydi

3.  b = np.random.permutation(a)   # nusxa

4.  seed(0) bir marta boshda

5.  np.random.choice(a, 5, replace=False)

Vazifa 3: seed

Modellang:

  1. Urug'
  2. Takrorlanuvchi
  3. Psevdo-tasodif
  4. Fan sharti

Vazifa 4: Tekis

Modellang:

  1. rand
  2. randint
  3. high
  4. uniform

Vazifa 5: normal

Modellang:

  1. O'rtacha
  2. std
  3. Qo'ng'iroq
  4. Real

Vazifa 6: Aralashtirish

Modellang:

  1. choice
  2. shuffle
  3. permutation
  4. train/test

Vazifa 7: O'ylash

Kompyuter tasodifiy sonlari aslida psevdo-tasodifiy (algoritm hisoblaydi), va seed bilan bir xil natijani qayta olish mumkin. Nima uchun bu "takrorlanuvchanlik" Data Science va ilm-fanda shunchalik muhim (garchi "tasodif takrorlanadi" g'alati tuyulsa ham), va nega haqiqiy tasodif (masalan fizik shovqindan) bu maqsad uchun yomonroq bo'lardi?

Javob

Qisqa javob: Kompyuter tasodifi psevdo-tasodifiy (algoritm — urug'dan hisoblaydi), seed bilan takrorlanadi; bu Data Science/fanda muhim, chunki: (1) takrorlanuvchanlik = fan asosi — fan tekshiriluvchi bo'lishi kerak (boshqalar natijani qayta oladi — isbot); tajriba seed(0) bilan — ertaga, boshqa kompyuterda bir xil natija (tekshirish mumkin); haqiqiy tasodif — qayta olib bo'lmaydi (har safar boshqa — tekshirib bo'lmaydi, fan buziladi); (2) debug — xato topish (kod noto'g'ri — seed bilan bir xil holat qayta yaratiladi, xato kuzatiladi); haqiqiy tasodif — har safar boshqa (xatoni takrorlab bo'lmaydi — debug qiyin); (3) taqqoslash — ikki model/usulni adolatli taqqoslash (bir xil train/test bo'lish — seed; farq usuldan, tasodifdan emas); haqiqiy tasodif — turli bo'lish (taqqoslash adolatsiz); (4) hamkorlik — jamoa bir xil natija (seed — hamma bir xil ko'radi; muammo birga hal). "Nega haqiqiy tasodif yomonroq (bu maqsad uchun)": (a) takrorlanmaydi — fizik shovqin (haqiqiy tasodif) har safar boshqa (natija qayta olinmaydi — tekshirib/debug qilib bo'lmaydi); (b) nazorat yo'q — tajribani boshqarib bo'lmaydi (bir xil holat yaratilmaydi); (c) sekin/qiyin — haqiqiy tasodif maxsus qurilma kerak (fizik manba — noqulay); psevdo — algoritm (tez, oddiy). "Nega g'alati tuyulsa ham to'g'ri": tasodif maqsadi — Data Science'da "bashorat qilib bo'lmas" emas (kriptografiya uchun shunday), balki "tartib/bias yo'q" (aralashgan — vakilli namuna); psevdo-tasodif bunga yetarli (statistik tasodifiy — tartib yo'q), lekin takrorlanuvchi (urug' — bonus); ya'ni Data Science "adolatli aralashish" xohlaydi (haqiqiy tasodif shart emas), "takrorlanuvchanlik" esa qo'shimcha qiymat (fan). Saboqlar: takrorlanuvchanlik = fan (tekshirish, qayta olish); debug (bir xil holat); adolatli taqqoslash (bir xil bo'lish); haqiqiy tasodif yomonroq (takrorlanmaydi, nazorat yo'q). To'g'ri: seed doim (fan/debug); haqiqiy tasodif faqat kriptografiya (bashorat qilib bo'lmaslik kerak bo'lsa). Muvozanat: tasodif (tartib yo'q — vakilli) + takrorlanuvchanlik (seed — fan) — ikkalasi psevdo-tasodifda. Bu fan usuli (takrorlanuvchi tajriba — isbot), Data Science asosi.

1. Nega takrorlanuvchanlik muhim

  • Fan asosi (tekshiriluvchi — qayta olish)
  • Debug (bir xil holat — xato kuzatish)
  • Adolatli taqqoslash (bir xil bo'lish)
  • Hamkorlik (jamoa bir xil natija)

2. Nega haqiqiy tasodif yomonroq

  • Takrorlanmaydi (qayta olib bo'lmaydi — tekshirish yo'q)
  • Nazorat yo'q (holatni yaratib bo'lmaydi)
  • Sekin/qiyin (fizik qurilma)

3. Nega g'alati tuyulsa ham to'g'ri

  • Data Science maqsad — tartib/bias yo'q (bashorat emas)
  • Psevdo yetarli (statistik tasodif)
  • Takrorlanuvchanlik — bonus (fan)

4. Taqqoslash

Psevdo (seed) Haqiqiy tasodif
Takrorlanuvchi (fan) Takrorlanmas
Debug/taqqoslash Nazorat yo'q

5. Saboqlar

  1. Takrorlanuvchanlik = fan (tekshirish)
  2. Debug (bir xil holat)
  3. Adolatli taqqoslash
  4. Haqiqiy tasodif yomonroq (bu maqsad)

6. Xulosa

  1. Psevdo-tasodif — takrorlanuvchi (seed)
  2. Takrorlanuvchanlik = fan asosi
  3. Haqiqiy tasodif — takrorlanmas (yomonroq)
  4. seed doim (fan/debug)

Nimani mustahkamlaydi: 2.1, 2.7-bo'limlar.

Xulosa

Bu darsda tasodifiy sonlarni o'rgandik.

Eng muhim uch fikr:

  1. seed va tekis tasodif. seed (urug') — takrorlanuvchanlik: np.random.seed(0) → tasodifiy sonlar doim bir xil (psevdo-tasodif — algoritm urug'dan hisoblaydi); Data Science shart (tajriba takrorlanuvchi, natija tekshiriluvchi — fan asosi). rand (0-1 kasr — tekis), randint (butun oraliq — high kirmaydi, randint(1, 7) = 1-6), uniform (oraliq kasr).

  2. normal va aralashtirish. normal (taqsimot) — normal/qo'ng'iroq (normal(o'rtacha, std, size) — o'rtacha atrofida ko'p, chetda kam; real dunyo — bo'y, baho); rand tekis, normal real. choice (ro'yxatdan tanlash — replace=False takrorsiz), shuffle (aralashtirish — joyida, asl o'zgaradi, None qaytaradi), permutation (aralashgan nusxa — asl saqlanadi).

  3. Takrorlanuvchi tasodif. Simulyatsiya — tasodifiy tajriba (tanga, zar — ko'p marta, ehtimollik; 10000 tanga → ~0.5). Random — takrorlanuvchi tasodif (seed + tasodif — tasodif kerak, lekin takrorlanuvchi; fan asosi, debug, adolatli taqqoslash). Data Science'da doim (train/test — shuffle+seed; statistika — simulyatsiya; ML — random_state). Tuzoqlar: seed unutish (takrorlanmaydi), randint high (kirmaydi), shuffle joyida (None, asl o'zgaradi), seed bir marta boshda.

Keyingi darsda chiziqli algebra (dot, matmul)ni o'rganamiz: vektor va matritsa ko'paytmasi, skalyar ko'paytma — ML va chuqur o'rganish matematikasi asosi.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
2.10-dars: Tasodifiy sonlar — IlmHamroh