IlmHamroh
Data Science va sun'iy intellekt/Ehtimollik8/10-dars16 daqiqa
Mundarija (22)

9.8-dars: Uzluksiz taqsimotlar

9-QISM — EHTIMOLLIK · 8-dars

1. Kirish va motivatsiya

9.7-darsda sanoqlar (nechta?) uchun diskret taqsimotlarni o'rgandik. Endi o'lchovlar (qancha? qancha vaqt?) uchun uzluksiz taqsimotlar: yetkazish vaqti, mijoz sarfi, server javob vaqti, bo'y, harorat. Normal taqsimotni 4.6-darsda ko'rgan edik; bu darsda uni boshqa muhim taqsimotlar qatoriga qo'yamiz va eng muhimi — ma'lumotga qaysi taqsimot mos kelishini qanday aniqlash va tekshirishni o'rganamiz.

To'rt asosiy uzluksiz taqsimot: tekis (uniform — hamma qiymat teng ehtimolli; tasodifiy sonlar generatori asosi), eksponensial (hodisalar orasidagi kutish vaqti — Poisson'ning "egizagi"), normal (ko'p kichik ta'sirlar yig'indisi — o'lchov xatolari, bo'y), log-normal (ko'p kichik ta'sirlar ko'paytmasi — narx, daromad, fayl hajmi — o'ngga qiyshiq, musbat). Pul va vaqt ma'lumotlari deyarli hech qachon normal emas — bu eng keng tarqalgan modellash xatosining manbai.

Real vaziyat. Tahlilchi mijozlar sarfini normal taqsimot deb modellaydi: o'rtacha ~224 ming, SD ~210 ming so'm. Model bo'yicha 14% mijoz manfiy summa sarflaydi — bema'nilik! Log-normal model (sarfning logarifmi normal) esa ham musbatlikni, ham o'ngga qiyshiqlikni, ham "kam sonli katta xaridorlar"ni to'g'ri aks ettiradi. Farq ayniqsa dumda: "eng yuqori 1% mijoz" chegarasi ma'lumotda ~1.03 mln, log-normal modelda ~1.05 mln, normal modelda esa atigi ~0.71 mln — normal model VIP mijozlarni 30% ga kam baholaydi. Noto'g'ri taqsimot — noto'g'ri xavf va imkoniyat bahosi.

Bu darsda uzluksiz taqsimotlarni o'rganamiz.

Bu darsda:

  • Tekis taqsimot (uniform)
  • Eksponensial taqsimot (kutish vaqti)
  • Normal taqsimot (qayta)
  • Log-normal taqsimot (narx, daromad)
  • Ma'lumotga taqsimot moslash (fit)
  • Moslikni tekshirish (QQ-plot, KS test)
  • Uzluksiz taqsimot tuzoqlari
  • Amaliy: kutish vaqti va sarf modellari

ℹ Misollar real numpy/scipy bilan (Python 3.14).

2. Nazariya — chuqur tushuntirish

2.1. Tekis taqsimot (uniform)

text
X ~ Uniform(a, b)       — [a, b] oraliqda hamma qiymat teng zichlikda

  f(x) = 1 / (b - a)
  E[X] = (a + b) / 2
  Var(X) = (b - a)^2 / 12

scipy: stats.uniform(loc=a, scale=b - a)     ← scale — kenglik, b emas!

Tekis taqsimot — "hech qanday ma'lumot yo'q, faqat chegaralar": avtobus har 10 daqiqada keladi, bekatga tasodifiy vaqtda keldingiz → kutish Uniform(0, 10), o'rtacha 5 daqiqa. Kompyuterda barcha tasodifiy sonlar tekis taqsimotdan boshlanadi (rng.random() — Uniform(0, 1)); boshqa taqsimotlar undan teskari CDF usuli bilan olinadi: U ~ Uniform(0, 1) bo'lsa, F^(-1)(U) — F taqsimotli. Tuzoq: scipy'da scale — kenglik (b - a).

2.2. Eksponensial taqsimot (kutish vaqti)

text
T ~ Exponential(lambda)  — Poisson hodisalari ORASIDAGI vaqt

  f(t) = lambda × e^(-lambda × t),  t >= 0
  E[T] = 1 / lambda,  SD = 1 / lambda
  P(T > t) = e^(-lambda × t)
  Xotirasiz: P(T > s + t | T > s) = P(T > t)

Soatiga 12 buyurtma (Poisson) → buyurtmalar orasidagi vaqt o'rtacha 5 daqiqa
scipy: stats.expon(scale=1 / lambda)          ← scale — o'rtacha, lambda emas!

Eksponensial — Poisson jarayonining ikkinchi yuzi: sanoq Poisson(lambda) bo'lsa, oraliqlar Exponential(lambda). Qo'llanilishi: mijozlar kelishi orasidagi vaqt, qurilma buzilishigacha vaqt (doimiy xavf), navbat nazariyasi. Xotirasiz — geometrikning uzluksiz ko'rinishi: 10 daqiqa kutgan bo'lsangiz ham, qolgan kutish yana o'rtacha 1/lambda. Real hayotda "eskirish" bo'lsa (xavf vaqt bilan o'sadi) — Weibull. Tuzoq: scipy scale = 1/lambda (o'rtacha vaqt).

2.3. Normal taqsimot (qayta)

Normal N(mu, sigma) — ko'p mustaqil kichik ta'sirlar yig'indisi (MLT, 4.7): o'lchov xatolari, bo'y, test ballari, namuna o'rtachalari. Simmetrik, dumlar tez so'nadi: 68-95-99.7 qoidasi 4.6-bob. Ehtiyot: real ma'lumotlarning ko'pi "normalga o'xshaydi", lekin dumlari og'irroq (moliyaviy daromadlar — "qora oqqushlar" normal modeldan ko'ra ancha ko'p). Normal — manfiy qiymatlarga ham ehtimol beradi: faqat musbat, qiyshiq o'lchovlar uchun (narx, vaqt) mos emas.

2.4. Log-normal taqsimot (narx, daromad)

text
X ~ LogNormal      <=>     log(X) ~ Normal(mu, sigma)

  X > 0 (har doim musbat), o'ngga qiyshiq
  median = e^mu,   E[X] = e^(mu + sigma^2 / 2)   (o'rtacha > median)

Qayerda: narx, daromad, mijoz sarfi, fayl hajmi, sessiya uzunligi, shahar aholisi
Sabab: ko'p kichik ta'sirlar KO'PAYTMASI (foizli o'sishlar)
scipy: stats.lognorm(s=sigma, scale=np.exp(mu))

Log-normal — "ko'paytmaviy" jarayonlar: har ta'sir oldingisini foizda o'zgartiradi (narx +10%, -5%, ...) → logarifm yig'indi → normal. Belgilari: faqat musbat, o'rtacha > median, uzun o'ng dum. Amaliy qoida: pul, vaqt, hajm ustunlarini logarifm (6.5, 8.3) bilan ko'ring — log qiymatlar normalga yaqin bo'lsa, log-normal. Tahlilni log shkalada qilish (o'rtacha, t-test, regressiya) ko'pincha to'g'riroq. scipy parametrlashuvi chalkash: s = sigma, scale = e^mu.

2.5. Ma'lumotga taqsimot moslash (fit)

Fit — ma'lumotga eng mos parametrlarni topish: stats.norm.fit(x) (mu, sigma), stats.expon.fit(x, floc=0), stats.lognorm.fit(x, floc=0) — maksimal ishonchlilik (maximum likelihood — ma'lumotni eng ehtimolli qiladigan parametrlar; 9.9). floc=0 — siljishni 0 da "qotirish" (musbat taqsimotlarda odatda shunday, aks holda noto'g'ri uch parametr baholanadi). Oddiy holatlarda momentlar usuli ham ishlaydi: eksponensial lambda = 1 / o'rtacha; log-normal — log(x) ning o'rtacha va SD si.

2.6. Moslikni tekshirish (QQ-plot, KS test)

Fit har doim biror parametr topadi — mos bo'lmasa ham! Tekshirish: (1) histogram + nazariy PDF ustma-ust 5.9-bob; (2) QQ-plot — ma'lumot kvantillari vs nazariy kvantillar (stats.probplot); to'g'ri chiziq — mos; chekkalarda egilish — dumlar farq qiladi; (3) kvantillarni solishtirish (5%, 50%, 95%, 99% — biznes uchun muhim nuqtalar); (4) KS test (stats.kstest) — rasmiy test, lekin katta n da kichik farqni ham "rad etadi", kichik n da katta farqni o'tkazib yuboradi — grafik bilan birga ishlating. Maqsad — "haqiqiy" taqsimot emas, qaror uchun yetarlicha mos model.

2.7. Uzluksiz taqsimot tuzoqlari

Asosiy tuzoqlar: pul/vaqtni normal deb (manfiy ehtimol, dumlar kam baholanadi); scipy parametrlari (uniform scale = kenglik, expon scale = 1/lambda, lognorm s = sigma, scale = e^mu); fit'ga ko'r-ko'rona ishonish (tekshirmasdan); floc ni qotirmaslik (musbat taqsimotda salbiy siljish — ma'nosiz model); o'rtacha va medianni adashtirish (log-normalda median = e^mu, o'rtacha katta); log(0) (nol qiymatlar — log1p yoki alohida ko'rish); KS test katta n da (amaliy ahamiyatsiz farqni "rad"); xotirasizlikni eskiruvchi jarayonga (uskuna eskiradi — eksponensial emas).

2.8. Uzluksiz taqsimotlar — o'lchov modellari

Uzluksiz taqsimotlar: tekis (chegaralar; E = (a + b)/2; generatorlar asosi, teskari CDF usuli), eksponensial (kutish vaqti; E = 1/lambda; xotirasiz; Poisson egizagi), normal (yig'indilar; MLT; simmetrik, yengil dumlar), log-normal (ko'paytmalar; musbat, o'ngga qiyshiq; narx, daromad; log bilan tahlil). Fit (maksimal ishonchlilik, floc=0) va tekshirish (histogram + PDF, QQ-plot, kvantillar, KS). Tanlash — jarayon tabiatidan (yig'indi/ko'paytma/kutish/chegara) va ma'lumotdan. Bog'lanishlar: 4.6 (normal), 5.9 (taqsimot grafiklari), 6.5 (log o'zgartirish), 9.7 (Poisson), 9.9 (maksimal ishonchlilik).

3. Tez ma'lumotnoma

python
import numpy as np
from scipy import stats

stats.uniform(loc=0, scale=10)          # Uniform(0, 10) — scale = kenglik
stats.expon(scale=5)                    # o'rtacha 5 (lambda = 0.2)
stats.norm(loc=100, scale=15)
stats.lognorm(s=0.8, scale=np.exp(12))  # log(X) ~ N(12, 0.8)

# FIT
mu, sigma = stats.norm.fit(x)
loc, scale = stats.expon.fit(x, floc=0)          # scale = o'rtacha
s, loc, scale = stats.lognorm.fit(x, floc=0)     # s = sigma, scale = e^mu

# TEKSHIRISH
stats.probplot(x, dist="norm")                   # QQ-plot ma'lumoti
stats.kstest(x, stats.expon(0, scale).cdf)
np.quantile(x, [0.5, 0.95, 0.99])                # vs model.ppf([...])

# TESKARI CDF USULI
u = rng.random(1000); t = stats.expon(scale=5).ppf(u)
QOIDA: pul/vaqt — normal emas · scipy parametrlarini tekshir · fit → tekshir (QQ, kvantil)

Uzluksiz taqsimotlar xulosasi

Uniform(a, b) — chegaralar; E = (a+b)/2; scale = b - a
Exponential — kutish vaqti; E = 1/lambda; xotirasiz; scale = 1/lambda
Normal — yig'indilar (MLT); simmetrik; manfiyga ham ehtimol
LogNormal — ko'paytmalar; musbat, qiyshiq; median = e^mu < o'rtacha
Fit — maksimal ishonchlilik (floc=0); tekshirish — QQ-plot, kvantillar, KS

4. Batafsil misollar

Misollar real numpy/scipy bilan (Python 3.14).

Misol 1 — Tekis taqsimot va teskari CDF usuli

python
"""Uniform: avtobus kutish; teskari CDF bilan boshqa taqsimot yaratish (real numpy/scipy)."""

import numpy as np
from scipy import stats


def main() -> None:
    print("=== 1. Avtobus har 10 daqiqada: kutish ~ Uniform(0, 10) ===")
    U = stats.uniform(loc=0, scale=10)
    print(f"  E = {U.mean():.1f}, SD = {U.std():.2f}")
    print(f"  P(kutish > 8) = {U.sf(8):.2f}")

    print("\n=== 2. scale — kenglik ===")
    print(f"  uniform(loc=5, scale=10): [{stats.uniform(5, 10).ppf(0):.0f}, {stats.uniform(5, 10).ppf(1):.0f}]")

    print("\n=== 3. Teskari CDF: Uniform(0,1) → eksponensial ===")
    rng = np.random.default_rng(0)
    u = rng.random(200_000)
    t = stats.expon(scale=5).ppf(u)
    print(f"  o'rtacha {t.mean():.3f} (nazariy 5), median {np.median(t):.3f} (nazariy {stats.expon(scale=5).median():.3f})")
    print("  ⭐ Barcha tasodifiy sonlar Uniform(0, 1) dan boshlanadi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Avtobus har 10 daqiqada: kutish ~ Uniform(0, 10) ===
  E = 5.0, SD = 2.89
  P(kutish > 8) = 0.20

=== 2. scale — kenglik ===
  uniform(loc=5, scale=10): [5, 15]

=== 3. Teskari CDF: Uniform(0,1) → eksponensial ===
  o'rtacha 4.984 (nazariy 5), median 3.448 (nazariy 3.466)
  ⭐ Barcha tasodifiy sonlar Uniform(0, 1) dan boshlanadi

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Eksponensial: Poisson egizagi

python
"""Eksponensial kutish vaqti va Poisson sanoq bog'liqligi (real numpy/scipy)."""

import numpy as np
from scipy import stats


def main() -> None:
    lam = 12 / 60                      # daqiqasiga 0.2 buyurtma (soatiga 12)
    T = stats.expon(scale=1 / lam)

    print("=== 1. Buyurtmalar orasidagi vaqt ===")
    print(f"  o'rtacha {T.mean():.1f} daqiqa, median {T.median():.2f}")
    print(f"  P(10 daqiqadan ko'p jimlik) = {T.sf(10):.3f}")

    print("\n=== 2. Oraliqlardan sanoqqa (simulyatsiya) ===")
    rng = np.random.default_rng(1)
    oraliq = rng.exponential(1 / lam, 2_000_000)
    vaqt = np.cumsum(oraliq)
    soat = (vaqt // 60).astype(int)
    sanoq = np.bincount(soat)[:-1]
    print(f"  soatiga: o'rtacha {sanoq.mean():.2f}, dispersiya {sanoq.var():.2f}  (Poisson: 12 va 12)")

    print("\n=== 3. Xotirasizlik ===")
    kutgan = oraliq[oraliq > 10] - 10
    print(f"  10 daqiqa kutganlarning qolgan kutishi: {kutgan.mean():.2f} (yana ~5)")
    print("  ⭐ Sanoq — Poisson, oraliq — eksponensial")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Buyurtmalar orasidagi vaqt ===
  o'rtacha 5.0 daqiqa, median 3.47
  P(10 daqiqadan ko'p jimlik) = 0.135

=== 2. Oraliqlardan sanoqqa (simulyatsiya) ===
  soatiga: o'rtacha 12.00, dispersiya 11.95  (Poisson: 12 va 12)

=== 3. Xotirasizlik ===
  10 daqiqa kutganlarning qolgan kutishi: 5.00 (yana ~5)
  ⭐ Sanoq — Poisson, oraliq — eksponensial

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Mijoz sarfi: normal vs log-normal

python
"""Pul ma'lumotiga normal va log-normal moslash (real numpy/scipy)."""

import numpy as np
from scipy import stats


def main() -> None:
    rng = np.random.default_rng(2)
    sarf = rng.lognormal(mean=12, sigma=0.8, size=5_000)      # so'm

    print("=== 1. Ma'lumot ===")
    print(f"  o'rtacha {sarf.mean():,.0f}, median {np.median(sarf):,.0f}")
    print(f"  skew {stats.skew(sarf):.2f}")

    print("\n=== 2. Normal fit ===")
    mu, sd = stats.norm.fit(sarf)
    N = stats.norm(mu, sd)
    print(f"  P(sarf < 0) modelda: {N.cdf(0):.1%}  ← bema'ni")

    print("\n=== 3. Log-normal fit (floc=0) ===")
    s, loc, scale = stats.lognorm.fit(sarf, floc=0)
    L = stats.lognorm(s, loc, scale)
    print(f"  sigma = {s:.3f}, mu = log(scale) = {np.log(scale):.3f}")

    print("\n=== 4. Kvantillar: ma'lumot / normal / log-normal ===")
    for q in [0.05, 0.5, 0.95, 0.99]:
        print(f"  {q:>4.0%}: {np.quantile(sarf, q):>9,.0f} / {N.ppf(q):>9,.0f} / {L.ppf(q):>9,.0f}")
    print("  ⭐ Pul — log-normal; normal dumlarni noto'g'ri beradi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Ma'lumot ===
  o'rtacha 223,998, median 164,207
  skew 3.19

=== 2. Normal fit ===
  P(sarf < 0) modelda: 14.1%  ← bema'ni

=== 3. Log-normal fit (floc=0) ===
  sigma = 0.801, mu = log(scale) = 12.000

=== 4. Kvantillar: ma'lumot / normal / log-normal ===
    5%:    42,901 /  -119,156 /    43,577
   50%:   164,207 /   223,998 /   162,755
   95%:   599,940 /   567,153 /   607,869
   99%: 1,028,265 /   709,329 / 1,049,337
  ⭐ Pul — log-normal; normal dumlarni noto'g'ri beradi

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

Misol 4 — Moslikni tekshirish: QQ va KS

python
"""QQ-plot korrelyatsiyasi va KS test bilan moslikni tekshirish (real numpy/scipy)."""

import numpy as np
from scipy import stats


def main() -> None:
    rng = np.random.default_rng(3)
    vaqt = rng.lognormal(mean=3, sigma=0.5, size=2_000)      # javob vaqti, ms

    print("=== 1. QQ-plot to'g'ri chiziqqa yaqinligi (r) ===")
    for nom, x, dist in [("xom vaqt vs normal", vaqt, "norm"),
                         ("log(vaqt) vs normal", np.log(vaqt), "norm"),
                         ("xom vaqt vs expon", vaqt, "expon")]:
        (_, _), (_, _, r) = stats.probplot(x, dist=dist)
        print(f"  {nom:<20}: r = {r:.4f}")

    print("\n=== 2. KS test ===")
    s, loc, scale = stats.lognorm.fit(vaqt, floc=0)
    for nom, model in [("lognorm", stats.lognorm(s, loc, scale)),
                       ("norm", stats.norm(*stats.norm.fit(vaqt)))]:
        res = stats.kstest(vaqt, model.cdf)
        print(f"  {nom:<8}: statistika {res.statistic:.4f}, p {res.pvalue:.4f}")

    print("\n=== 3. Katta n da KS juda sezgir ===")
    katta = rng.standard_t(df=30, size=200_000)               # normalga juda yaqin
    print(f"  t(30) vs normal, n=200 000: p = {stats.kstest(katta, stats.norm(*stats.norm.fit(katta)).cdf).pvalue:.4f}")
    print("  ⭐ Grafik + kvantillar + test — birga")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. QQ-plot to'g'ri chiziqqa yaqinligi (r) ===
  xom vaqt vs normal  : r = 0.9379
  log(vaqt) vs normal : r = 0.9997
  xom vaqt vs expon   : r = 0.9907

=== 2. KS test ===
  lognorm : statistika 0.0123, p 0.9208
  norm    : statistika 0.1047, p 0.0000

=== 3. Katta n da KS juda sezgir ===
  t(30) vs normal, n=200 000: p = 0.0001
  ⭐ Grafik + kvantillar + test — birga

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

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

Noto'g'ri fikr To'g'risi
"Hamma narsa normal" Pul, vaqt — ko'pincha log-normal
"expon(scale=lambda)" scale = 1/lambda
"uniform(a, b)" uniform(loc=a, scale=b-a)
"Fit topdi — demak mos" Fit har doim topadi; tekshiring
"Log-normal o'rtacha = e^mu" e^mu — median
"KS p < 0.05 — model yaroqsiz" Katta n da juda sezgir
"Kutish vaqti har doim xotirasiz" Eskiruvchi jarayon — Weibull
"Normal manfiy qiymat bermaydi" Beradi — pulga mos emas

6. Keng tarqalgan xatolar va yechimlari

1. expon parametri

python
T = stats.expon(scale=0.2)          # lambda deb                    # ⚠️
T = stats.expon(scale=1 / 0.2)      # o'rtacha 5                    # ✅

2. uniform parametri

python
U = stats.uniform(5, 15)            # [5, 15] deb — aslida [5, 20]  # ⚠️
U = stats.uniform(loc=5, scale=10)  # [5, 15]                       # ✅

3. lognorm fit siljishi

python
s, loc, scale = stats.lognorm.fit(x)            # loc erkin         # ⚠️
s, loc, scale = stats.lognorm.fit(x, floc=0)                        # ✅

4. Pulga normal

python
model = stats.norm(*stats.norm.fit(sarf))                           # ⚠️
model = stats.lognorm(*stats.lognorm.fit(sarf, floc=0))             # ✅

5. log(0)

python
np.log(sarf)                        # 0 → -inf                      # ⚠️
np.log1p(sarf)                      # yoki nollarni alohida         # ✅

6. Fit'ni tekshirmaslik

python
params = stats.expon.fit(x)         # va tamom                      # ⚠️
# histogram + pdf, probplot, kvantillar solishtiriladi              # ✅

7. Median va o'rtacha

python
ortacha = np.exp(mu)                # log-normal                    # ⚠️
ortacha = np.exp(mu + sigma ** 2 / 2)                               # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 4.6-dars (o'tilgan): Normal taqsimot
  • 5.9-dars (o'tilgan): Histogram, KDE
  • 6.5-dars (o'tilgan): Log o'zgartirish
  • 9.7-dars (o'tilgan): Poisson (eksponensial egizagi)
  • 9.9-dars: Maksimal ishonchlilik (fit asosi)

8. Eng yaxshi amaliyotlar

  1. Jarayon tabiatidan boshlang (yig'indi/ko'paytma/kutish).

  2. Pul va vaqtni log shkalada ko'ring.

  3. scipy parametrlarini hujjatdan tekshiring.

  4. Musbat taqsimot fit'ida floc=0.

  5. Fit'dan keyin — histogram + PDF, QQ-plot.

  6. Biznes kvantillarini (95%, 99%) solishtiring.

  7. KS natijasini grafik bilan talqin qiling.

  8. Model — qaror uchun yetarli bo'lsa, yetarli.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # Uniform(0, 10) E?
2.  # Uniform(0, 10) Var?
3.  # soatiga 6 hodisa → o'rtacha kutish?
4.  # stats.expon(scale=?) — lambda = 0.5
5.  # expon xotirasizmi?
6.  # narx uchun qaysi taqsimot?
7.  # log-normal median?
8.  # log-normal o'rtacha > median?
9.  # uniform(3, 4) oralig'i?
10. # QQ-plot to'g'ri chiziq nimani anglatadi?
11. # KS katta n da?
12. # fit(x, floc=0) nima uchun?
Javoblar
  1. 5
  2. 100/12 ≈ 8.33
  3. 10 daqiqa
  4. 2
  5. Ha
  6. Log-normal
  7. e^mu
  8. Ha
  9. [3, 7]
  10. Taqsimot mos
  11. Juda sezgir (kichik farqni ham rad etadi)
  12. Siljishni 0 da qotirish (musbat taqsimot)

Vazifa 2: Xatolarni tuzating

python
1.  T = stats.expon(scale=3)   # soatiga 3 hodisa, soatlarda kutish

2.  U = stats.uniform(10, 20)   # [10, 20]

3.  model = stats.norm(*stats.norm.fit(daromad))

4.  ortacha = np.exp(mu)   # log-normal kutilmasi

5.  x_log = np.log(sessiya)   # 0 qiymatlar bor
Javoblar
python
1.  T = stats.expon(scale=1 / 3)

2.  U = stats.uniform(loc=10, scale=10)

3.  model = stats.lognorm(*stats.lognorm.fit(daromad, floc=0))

4.  ortacha = np.exp(mu + sigma ** 2 / 2)

5.  x_log = np.log1p(sessiya)

Vazifa 3: Kutish vaqti

Modellang:

  1. Qo'ng'iroqlar orasidagi vaqt ma'lumoti
  2. expon fit (floc=0)
  3. 1 daqiqadan uzoq jimlik ehtimoli
  4. Soatlik sanoq — Poisson tekshiruvi

Vazifa 4: Daromad modeli

Modellang:

  1. 10 000 mijoz daromadi
  2. Normal va log-normal fit
  3. 95%, 99% kvantillar solishtirish
  4. Qaysi model — nega

Vazifa 5: Moslik

Modellang:

  1. Uch xil ma'lumot (normal, log-normal, eksponensial)
  2. Har biriga uch taqsimot fit
  3. QQ r va KS
  4. Jadval va xulosa

Vazifa 6: Integratsiya

Modellang:

  1. Normal (4.6)
  2. KDE (5.9)
  3. Log o'zgartirish (6.5)
  4. Poisson (9.7)

Vazifa 7: O'ylash

2008-yilgi moliyaviy inqirozdan oldin ko'p xavf modellari bozor o'zgarishlarini normal taqsimot bilan modellashtirgan. Normal model bo'yicha "25 sigma" hodisa koinot yoshidan ham kamroq ehtimolli edi — lekin bir necha kunda bir necha marta ro'y berdi. Noto'g'ri taqsimot tanlash xavfni qanday kam baholaydi? Data Scientist "dum" (tail) xavfini qanday hisobga olishi kerak?

Javob

Qisqa javob: normal taqsimotning dumlari juda tez so'nadi — ekstremal hodisalarga deyarli nol ehtimol beradi. Real moliyaviy (va ko'p biznes) ma'lumotlarda dumlar ancha "og'ir": ekstremal hodisalar normal model aytganidan yuzlab-minglab marta tez-tez ro'y beradi. Xavf aynan dumda — normal model uni ko'rmaydi.

1. Nega normal xavfli

  • Model markazga moslashadi (ko'p ma'lumot o'sha yerda), dumlarni kam baholaydi
  • "Sigma" o'lchovi normal farazga bog'liq — og'ir dumda ma'nosiz
  • Bog'liqlik: inqirozda aktivlar birga tushadi (mustaqillik yo'qoladi)

2. Dumni solishtirish

Hodisa Normal model Og'ir dumli model
4 sigma ~1/16 000 ~1/300
6 sigma ~1/500 mln ~1/3 000
Oqibat "Imkonsiz" "Kam, lekin kutiladi"

3. Data Scientist qanday

  1. Dumni alohida tekshiradi (QQ-plot chekkalari, 99% va 99.9% kvantillar)
  2. Og'ir dumli taqsimotlar (t, log-normal, Pareto) bilan solishtiradi
  3. Tarixiy stress-ssenariylar (eng yomon kunlar) bilan sinaydi
  4. Model noaniqligini hisobotda ochiq aytadi (8.9)

4. Biznesdagi misollar

  • Talab cho'qqilari (bayram, aksiya) — sig'im rejasi
  • Katta sug'urta da'volari, katta firibgarlik
  • Server yuklamasi cho'qqilari — p99 kechikish

5. Xulosa

  1. Taqsimot tanlash — xavf bahosini belgilaydi
  2. Normal — dumlarni keskin kam baholaydi
  3. Xavf dumda: dumni alohida tekshiring
  4. "Imkonsiz" hodisa ko'pincha — noto'g'ri model belgisi

Nimani mustahkamlaydi: 2.3, 2.6, 2.7-bo'limlar.

Xulosa

Bu darsda uzluksiz taqsimotlarni o'rgandik.

Eng muhim uch fikr:

  1. To'rt model. Tekis (chegaralar; generatorlar asosi, teskari CDF usuli); eksponensial (kutish vaqti; E = 1/lambda; xotirasiz; Poisson sanoqning oraliqlari); normal (yig'indilar, MLT; simmetrik, yengil dumlar); log-normal (ko'paytmalar; musbat, o'ngga qiyshiq; median = e^mu < o'rtacha — pul, vaqt, hajm).

  2. Fit va tekshirish. dist.fit(x, floc=0) — maksimal ishonchlilik; fit har doim natija beradi — shuning uchun tekshiring: histogram + PDF, QQ-plot, biznes kvantillari (95%, 99%), KS test (katta n da o'ta sezgir). Pul ma'lumotiga normal — manfiy ehtimol va noto'g'ri dumlar.

  3. scipy parametrlari va dumlar. uniform scale = kenglik, expon scale = 1/lambda, lognorm s = sigma, scale = e^mu. Xavf dumda: noto'g'ri taqsimot ekstremal hodisalarni "imkonsiz" deb ko'rsatadi.

Keyingi darsda ehtimollik va ML bog'lanishini o'rganamiz: maksimal ishonchlilik (likelihood), log-loss, predict_proba va kalibrlash, Naive Bayes — ehtimollik qismining barcha g'oyalari Machine Learning'da qanday ishlaydi.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!