Data Science va sun'iy intellekt11.8-dars: Bootstrap va permutatsiya
Data Science va sun'iy intellekt · Gipoteza testlari

11.8-dars: Bootstrap va permutatsiya

17 daqiqa8/10-dars

11-QISM — GIPOTEZA TESTLARI · 8-dars


1. Kirish va motivatsiya

Klassik testlar (t-test, z-test, ANOVA) formulalarga tayanadi va shuning uchun cheklangan: ular faqat ma'lum statistikalar (o'rtacha, ulush) va ma'lum farazlar ostida ishlaydi. Amalda esa savollar boshqacha bo'ladi: "median chekning farqi qancha?", "konversiyaning nisbiy o'sishi uchun ishonch oralig'i?", "90-persentil yuklanish vaqti yaxshilandimi?", "ikki model AUC farqi ishonchlimi?". Bu statistikalar uchun oddiy formula yo'q.

Bootstrap va permutatsiya — qayta namuna olishga asoslangan universal usullar: kompyuter formulani almashtiradi. Bootstrap ma'lumotdan qaytarib namunalar olib, har qanday statistikaning taqsimotini (va ishonch oralig'ini) tiklaydi. Permutatsiya testi esa guruh yorliqlarini aralashtirib, H0 dunyosini to'g'ridan-to'g'ri quradi va p-qiymat beradi. Ikkalasi ham 9.1-darsdagi Monte Carlo g'oyasining amaliy davomi.

Real vaziyat. Jamoa A/B test natijasini hisobot qilmoqchi: "konversiya 4.0% dan 4.6% ga oshdi — 15% nisbiy o'sish". Menejer so'raydi: "15% o'sishning ishonch oralig'i qancha?". Absolyut farq uchun formula bor 11.4-bob, nisbiy farq uchun — yo'q. Data Scientist bootstrap qiladi: 10 000 marta qayta namuna olib, har safar nisbiy o'sishni hisoblaydi; natija — [-4%, +39%] (Misol 1). Endi menejer ko'radi: "15% o'sish" juda noaniq baho — hatto kichik pasayish ham istisno qilinmaydi. Qaror shu noaniqlik bilan qabul qilinadi.

Bu darsda bootstrap va permutatsiya testlarini o'rganamiz.

Bu darsda:

  • Bootstrap g'oyasi va ishonch oralig'i
  • Permutatsiya testi va p-qiymat
  • Har qanday statistika uchun CI (median, nisbat, persentil)
  • scipy vositalari (bootstrap, permutation_test)
  • Juftlashgan va klasterlangan ma'lumot
  • Cheklovlar va xatolar
  • Bootstrap tuzoqlari
  • Amaliy: A/B natijasini to'liq hisobot qilish

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


2. Nazariya — chuqur tushuntirish

2.1. Bootstrap g'oyasi

text
Muammo: bizda bitta namuna bor; statistikaning (masalan, median) noaniqligi qancha?
G'oya:  namunaning o'zini "populyatsiya" deb olib, undan QAYTARIB namunalar olamiz

1. Asl namuna: n ta kuzatuv
2. B marta (masalan, 10 000): n ta kuzatuvni QAYTARIB tanlaymiz (ba'zilari takrorlanadi)
3. Har namunada statistikani hisoblaymiz → statistikaning taqsimoti
4. Ishonch oralig'i: persentil usuli — [2.5%, 97.5%] kvantillari

rng.choice(x, size=len(x), replace=True)

Bootstrap — "o'zini o'zi ko'tarish": namuna populyatsiyaning eng yaxshi mavjud tasviri, shuning uchun undan qayta namunalar olib, statistikaning tebranishini modellaymiz. Natija — har qanday statistika uchun ishonch oralig'i (median, kvartil, nisbat, korrelyatsiya, model metrikasi). Shart: kuzatuvlar mustaqil va namuna populyatsiyani vakillik qiladi.

2.2. Permutatsiya testi

text
Muammo: ikki guruh farqi uchun p-qiymat (formula yo'q yoki farazlar buzilgan)
G'oya:  H0 rost bo'lsa, guruh yorlig'i ahamiyatsiz — ularni aralashtirish mumkin

1. Kuzatilgan statistika: masalan, medianlar farqi = 5.2
2. B marta: barcha qiymatlarni birlashtirib, yorliqlarni TASODIFIY aralashtirish,
   har safar statistikani hisoblash → H0 taqsimoti
3. p = (|aralash statistika| >= |kuzatilgan|) ulushi

Juftlashgan dizaynda: har juftlik ichida ishoralarni tasodifiy almashtirish

Permutatsiya testi — H0 dunyosini ma'lumotning o'zidan quradi: "agar guruhlar orasida farq bo'lmasa, yorliqlarni aralashtirganda kuzatilgandek farq qanchalik tez-tez chiqadi?". Farazlar minimal (asosan almashuvchanlik — exchangeability). Bu 9.1-darsdagi simulyatsiya g'oyasining aniq shakli. Natija — aniq va tushunarli p-qiymat, istalgan statistika uchun.

2.3. Har qanday statistika uchun CI

text
Bootstrap ishlaydigan holatlar:
  median, kvartillar, 90-persentil (SLA metrikalari)
  nisbat: konversiyaning nisbiy o'sishi, ikki metrika nisbati
  korrelyatsiya, R^2, AUC, model metrikalari farqi
  murakkab hisob: "top-10% mijozlar ulushi"

Persentil CI:  np.percentile(bootstrap_qiymatlar, [2.5, 97.5])
BCa (tuzatilgan): scipy.stats.bootstrap(..., method="BCa") — qiyshiqlikni tuzatadi

Bootstrap ning asosiy afzalligi — universallik: formula bor-yo'qligidan qat'i nazar ishlaydi. Persentil usuli sodda va ko'p holatda yetarli; BCa (bias-corrected and accelerated) qiyshiq taqsimotlarda aniqroq va scipy'da standart — lekin u jackknife hisoblaydi, shuning uchun katta namunada (o'n minglab qator) juda ko'p xotira talab qiladi: u yerda method="percentile" ishlating. B (takrorlar soni) — CI uchun kamida 2 000, odatda 10 000.

2.4. scipy vositalari

python
from scipy import stats

# bootstrap CI
res = stats.bootstrap((x,), np.median, confidence_level=0.95,
                      n_resamples=10_000, random_state=0)
res.confidence_interval.low, res.confidence_interval.high

# ikki namunali statistikaga
stats.bootstrap((a, b), lambda a, b: np.median(a) - np.median(b), ...)

# permutatsiya testi
stats.permutation_test((a, b), lambda a, b: np.mean(a) - np.mean(b),
                       permutation_type="independent", n_resamples=10_000, random_state=0)

scipy.stats.bootstrap — CI uchun (BCa standart; paired=True juftlashgan ma'lumot uchun; vectorized bilan tezlashtirish). scipy.stats.permutation_test — p-qiymat uchun: permutation_type="independent" (ikki mustaqil guruh), "samples" (juftlashgan — ishoralarni almashtirish), "pairings" (korrelyatsiya testi). Ikkalasida ham random_state bilan takrorlanuvchanlik.

2.5. Juftlashgan va klasterlangan ma'lumot

Bootstrap/permutatsiya mustaqillik farazini talab qiladi — shuning uchun qayta namuna olish to'g'ri birlik darajasida bo'lishi kerak: juftlashgan dizaynda juftliklar (yoki farqlar) qayta namuna olinadi; klasterlangan ma'lumotda (bir foydalanuvchining ko'p sessiyasi) — foydalanuvchilar (klaster bootstrap): tasodifiy foydalanuvchilarni qaytarib tanlab, ularning barcha yozuvlarini olish. Yozuvlar darajasida bootstrap qilish — 11.3 dagi soxta mustaqillik xatosining bootstrap ko'rinishi.

2.6. Cheklovlar va xatolar

text
Bootstrap YOMON ishlaydigan holatlar:
  - juda kichik namuna (n < 10-15): namunada bo'lmagan narsani tiklay olmaydi
  - ekstremal statistikalar: maksimum, minimum
  - kuchli bog'liq ma'lumot (vaqt qatorlari — blok bootstrap kerak)
  - og'ir dumli taqsimotlar (dispersiya cheksiz)

Permutatsiya testi:
  - H0 "yorliqlar ahamiyatsiz" bo'lishi kerak (almashuvchanlik)
  - guruhlar dispersiyasi juda farqli bo'lsa, natija chalkash bo'lishi mumkin

Bootstrap sehr emas: u faqat namunadagi ma'lumotni qayta ishlatadi. Agar namuna vakillik qilmasa (tanlov tarafkashligi), bootstrap CI noto'g'ri bo'ladi — u faqat namuna olish noaniqligini o'lchaydi, tarafkashlikni emas. Ekstremal statistikalar (maksimum) uchun bootstrap ishlamaydi. Vaqt qatorlarida — blok bootstrap (ketma-ket bo'laklarni tanlash).

2.7. Bootstrap tuzoqlari

Asosiy tuzoqlar: noto'g'ri birlik (sessiya emas, foydalanuvchi — klaster bootstrap); juftlashgan ma'lumotni mustaqil deb qayta namuna olish; kichik B (100 ta takror — CI beqaror; kamida 2 000); random_state siz (takrorlanmaydigan natija); tanlov tarafkashligini "davolash" (bootstrap uni tuzatmaydi); maksimum/minimum uchun bootstrap; vaqt qatorida oddiy bootstrap; bootstrap p-qiymatini permutatsiya o'rniga (CI uchun bootstrap, test uchun permutatsiya odatda aniqroq); katta namunada BCa (xotira portlashi — method="percentile"); juda sekin kod (sikl o'rniga vektorlashtirish — 2.12).

2.8. Qayta namuna olish — universal vosita

Bootstrap — namunadan qaytarib qayta namunalar olib, har qanday statistika uchun taqsimot va ishonch oralig'i quradi (persentil yoki BCa; B >= 2 000). Permutatsiya testi — yorliqlarni aralashtirib H0 dunyosini quradi va p-qiymat beradi (almashuvchanlik farazi). Qayta namuna olish to'g'ri birlik darajasida (foydalanuvchi, juftlik). Cheklovlar: kichik namuna, ekstremal statistikalar, bog'liq ma'lumot, tanlov tarafkashligi. Bu usullar formulalar yetmaganda — median, nisbiy o'sish, persentil, model metrikalari uchun asosiy yechim. Keyingi dars — ko'p taqqoslash muammosi va uning tuzatishlari.


3. Tez ma'lumotnoma

python
import numpy as np
from scipy import stats

rng = np.random.default_rng(0)

# BOOTSTRAP (qo'lda)
B = 10_000
namunalar = rng.choice(x, size=(B, len(x)), replace=True)
statistikalar = np.median(namunalar, axis=1)
lo, hi = np.percentile(statistikalar, [2.5, 97.5])

# BOOTSTRAP (scipy, BCa)
res = stats.bootstrap((x,), np.median, n_resamples=10_000, random_state=0)
res.confidence_interval

# IKKI GURUH FARQI
stats.bootstrap((a, b), lambda u, v, axis=-1: np.median(u, axis=axis) - np.median(v, axis=axis),
                vectorized=True, n_resamples=10_000, random_state=0)

# PERMUTATSIYA TESTI
stats.permutation_test((a, b), lambda u, v, axis=-1: u.mean(axis) - v.mean(axis),
                       permutation_type="independent", vectorized=True,
                       n_resamples=10_000, random_state=0)

# KLASTER BOOTSTRAP (foydalanuvchi darajasi)
userlar = df["user_id"].unique()
tanlov = rng.choice(userlar, size=len(userlar), replace=True)
QOIDA: birlik — foydalanuvchi · B >= 2000 · random_state · CI bootstrap, test permutatsiya

Bootstrap xulosasi

Bootstrap — qaytarib qayta namuna; har qanday statistika uchun CI
Permutatsiya — yorliqlarni aralashtirish; H0 taqsimoti va p
Birlik: foydalanuvchi/juftlik (klaster bootstrap, paired=True)
B >= 2000 (CI uchun 10 000 yaxshi); random_state bilan
Cheklov: kichik n, maksimum/minimum, bog'liq ma'lumot, tanlov tarafkashligi

4. Batafsil misollar

Misollar real numpy/scipy bilan (Python 3.14).

Misol 1 — Bootstrap CI: median va nisbiy o'sish

python
"""Bootstrap: median CI va konversiyaning nisbiy o'sishi CI (real numpy/scipy)."""

import numpy as np
from scipy import stats


def main() -> None:
    rng = np.random.default_rng(0)

    print("=== 1. Median chek uchun CI (qiyshiq ma'lumot) ===")
    chek = rng.lognormal(np.log(180_000), 0.7, 400)
    B = 10_000
    namunalar = rng.choice(chek, size=(B, len(chek)), replace=True)
    medianlar = np.median(namunalar, axis=1)
    lo, hi = np.percentile(medianlar, [2.5, 97.5])
    print(f"  median: {np.median(chek):,.0f} so'm, 95% CI [{lo:,.0f}, {hi:,.0f}]")

    print("\n=== 2. scipy.stats.bootstrap (BCa) ===")
    res = stats.bootstrap((chek,), np.median, n_resamples=10_000, random_state=0)
    print(f"  BCa CI: [{res.confidence_interval.low:,.0f}, {res.confidence_interval.high:,.0f}]")

    print("\n=== 3. Konversiyaning NISBIY o'sishi (formula yo'q) ===")
    nA, xA, nB, xB = 5000, 200, 5000, 230          # 4.0% va 4.6%
    a = np.concatenate([np.ones(xA), np.zeros(nA - xA)])
    b = np.concatenate([np.ones(xB), np.zeros(nB - xB)])
    lift = np.empty(B)
    for i in range(B):
        pa = rng.choice(a, nA, replace=True).mean()
        pb = rng.choice(b, nB, replace=True).mean()
        lift[i] = (pb - pa) / pa
    print(f"  kuzatilgan lift: {(xB / nB - xA / nA) / (xA / nA):+.1%}")
    print(f"  95% CI: [{np.percentile(lift, 2.5):+.1%}, {np.percentile(lift, 97.5):+.1%}]")

    print("\n=== 4. 90-persentil (SLA) uchun CI ===")
    vaqt = rng.lognormal(np.log(120), 0.6, 500)
    res90 = stats.bootstrap((vaqt,), lambda v, axis=-1: np.percentile(v, 90, axis=axis),
                            vectorized=True, n_resamples=5_000, random_state=0)
    print(f"  p90 = {np.percentile(vaqt, 90):.0f} ms, "
          f"CI [{res90.confidence_interval.low:.0f}, {res90.confidence_interval.high:.0f}]")
    print("  ⭐ Bootstrap — har qanday statistika uchun CI")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Median chek uchun CI (qiyshiq ma'lumot) ===
  median: 173,784 so'm, 95% CI [155,990, 190,684]

=== 2. scipy.stats.bootstrap (BCa) ===
  BCa CI: [156,069, 190,831]

=== 3. Konversiyaning NISBIY o'sishi (formula yo'q) ===
  kuzatilgan lift: +15.0%
  95% CI: [-4.1%, +38.7%]

=== 4. 90-persentil (SLA) uchun CI ===
  p90 = 262 ms, CI [238, 300]
  ⭐ Bootstrap — har qanday statistika uchun CI

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

Misol 2 — Permutatsiya testi

python
"""Permutatsiya testi: o'rtacha va median farqi uchun p-qiymat (real numpy/scipy)."""

import numpy as np
from scipy import stats


def main() -> None:
    rng = np.random.default_rng(1)
    a = rng.lognormal(np.log(31), 0.5, 120)
    b = rng.lognormal(np.log(26), 0.5, 120)

    print("=== 1. Kuzatilgan ===")
    print(f"  o'rtachalar: {a.mean():.2f} va {b.mean():.2f}; "
          f"medianlar: {np.median(a):.2f} va {np.median(b):.2f}")

    print("\n=== 2. Permutatsiya: o'rtachalar farqi ===")
    res = stats.permutation_test(
        (a, b), lambda u, v, axis=-1: u.mean(axis=axis) - v.mean(axis=axis),
        permutation_type="independent", vectorized=True, n_resamples=10_000, random_state=0)
    print(f"  kuzatilgan farq {res.statistic:+.3f}, p = {res.pvalue:.4f}")
    print(f"  t-test p = {stats.ttest_ind(a, b, equal_var=False).pvalue:.4f}")

    print("\n=== 3. Permutatsiya: medianlar farqi (formula yo'q) ===")
    res_m = stats.permutation_test(
        (a, b), lambda u, v, axis=-1: np.median(u, axis=axis) - np.median(v, axis=axis),
        permutation_type="independent", vectorized=True, n_resamples=10_000, random_state=0)
    print(f"  kuzatilgan farq {res_m.statistic:+.3f}, p = {res_m.pvalue:.4f}")

    print("\n=== 4. Qo'lda permutatsiya (g'oyani ko'rsatish) ===")
    hammasi = np.concatenate([a, b])
    kuzatilgan = a.mean() - b.mean()
    rng2 = np.random.default_rng(2)
    farqlar = np.empty(10_000)
    for i in range(10_000):
        aralash = rng2.permutation(hammasi)
        farqlar[i] = aralash[:len(a)].mean() - aralash[len(a):].mean()
    p_qolda = (np.abs(farqlar) >= abs(kuzatilgan)).mean()
    print(f"  p (qo'lda) = {p_qolda:.4f}; H0 taqsimoti SD = {farqlar.std():.3f}")
    print("  ⭐ Permutatsiya — H0 dunyosini ma'lumotdan qurish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Kuzatilgan ===
  o'rtachalar: 32.91 va 27.52; medianlar: 31.48 va 23.62

=== 2. Permutatsiya: o'rtachalar farqi ===
  kuzatilgan farq +5.386, p = 0.0062
  t-test p = 0.0058

=== 3. Permutatsiya: medianlar farqi (formula yo'q) ===
  kuzatilgan farq +7.856, p = 0.0002

=== 4. Qo'lda permutatsiya (g'oyani ko'rsatish) ===
  p (qo'lda) = 0.0057; H0 taqsimoti SD = 1.956
  ⭐ Permutatsiya — H0 dunyosini ma'lumotdan qurish

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

Misol 3 — Klaster bootstrap va juftlashgan dizayn

python
"""To'g'ri birlik: klaster (foydalanuvchi) bootstrap va juftlashgan permutatsiya (real numpy/scipy)."""

import numpy as np
from scipy import stats


def main() -> None:
    rng = np.random.default_rng(3)

    print("=== 1. Klasterlangan ma'lumot: 100 foydalanuvchi × 10 sessiya ===")
    shaxsiy = rng.normal(50, 12, 100)
    sessiya = shaxsiy[:, None] + rng.normal(0, 3, (100, 10))
    yassi = sessiya.ravel()

    B = 5000
    # noto'g'ri: sessiya darajasida
    noto = np.array([rng.choice(yassi, len(yassi), replace=True).mean() for _ in range(B)])
    # to'g'ri: foydalanuvchi darajasida
    togri = np.array([sessiya[rng.integers(0, 100, 100)].mean() for _ in range(B)])
    print(f"  o'rtacha: {yassi.mean():.2f}")
    print(f"  sessiya bootstrap CI: [{np.percentile(noto, 2.5):.2f}, {np.percentile(noto, 97.5):.2f}]"
          f"  (kenglik {np.percentile(noto, 97.5) - np.percentile(noto, 2.5):.2f})")
    print(f"  klaster bootstrap CI: [{np.percentile(togri, 2.5):.2f}, {np.percentile(togri, 97.5):.2f}]"
          f"  (kenglik {np.percentile(togri, 97.5) - np.percentile(togri, 2.5):.2f})")

    print("\n=== 2. Juftlashgan dizayn: permutatsiya (ishoralarni almashtirish) ===")
    baza = rng.lognormal(np.log(60), 0.4, 40)
    oldin = baza * rng.lognormal(0, 0.1, 40)
    keyin = baza * 0.9 * rng.lognormal(0, 0.1, 40)
    res = stats.permutation_test(
        (oldin - keyin,), lambda d, axis=-1: np.mean(d, axis=axis),
        permutation_type="samples", vectorized=True, n_resamples=10_000, random_state=0)
    print(f"  o'rtacha farq {res.statistic:+.2f}s, p = {res.pvalue:.4f}")
    print(f"  juftlashgan t-test p = {stats.ttest_rel(oldin, keyin).pvalue:.4f}")

    print("\n=== 3. Juftlashgan bootstrap CI ===")
    farq = oldin - keyin
    res_b = stats.bootstrap((farq,), np.mean, n_resamples=10_000, random_state=0)
    print(f"  CI [{res_b.confidence_interval.low:+.2f}, {res_b.confidence_interval.high:+.2f}]")
    print("  ⭐ Qayta namuna — mustaqil birlik darajasida")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Klasterlangan ma'lumot: 100 foydalanuvchi × 10 sessiya ===
  o'rtacha: 49.39
  sessiya bootstrap CI: [48.58, 50.21]  (kenglik 1.63)
  klaster bootstrap CI: [46.87, 51.90]  (kenglik 5.03)

=== 2. Juftlashgan dizayn: permutatsiya (ishoralarni almashtirish) ===
  o'rtacha farq +7.70s, p = 0.0002
  juftlashgan t-test p = 0.0000

=== 3. Juftlashgan bootstrap CI ===
  CI [+4.80, +10.66]
  ⭐ Qayta namuna — mustaqil birlik darajasida

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

Misol 4 — Bootstrap qamrovi va cheklovlari

python
"""Bootstrap CI qamrovi; kichik namuna va maksimum uchun buzilishi (real numpy/scipy)."""

import numpy as np


def main() -> None:
    rng = np.random.default_rng(4)
    B, N = 2000, 1000

    print("=== 1. O'rtacha uchun qamrov (log-normal, haqiqiy o'rtacha ma'lum) ===")
    haqiqiy = np.exp(3 + 0.8 ** 2 / 2)
    for n in [10, 30, 100, 400]:
        qamrov = 0
        for _ in range(N):
            x = rng.lognormal(3, 0.8, n)
            boot = np.median if False else np.mean
            qiymatlar = boot(rng.choice(x, size=(B, n), replace=True), axis=1)
            lo, hi = np.percentile(qiymatlar, [2.5, 97.5])
            qamrov += lo <= haqiqiy <= hi
        print(f"  n={n:>3}: qamrov {qamrov / N:.3f}  (maqsad 0.95)")

    print("\n=== 2. Maksimum uchun bootstrap ishlamaydi ===")
    x = rng.uniform(0, 100, 200)
    boot_max = np.max(rng.choice(x, size=(5000, 200), replace=True), axis=1)
    print(f"  namuna maksimumi: {x.max():.2f}")
    print(f"  bootstrap CI: [{np.percentile(boot_max, 2.5):.2f}, {np.percentile(boot_max, 97.5):.2f}]")
    print("  haqiqiy maksimum 100 — CI uni o'z ichiga olmaydi (namunadan katta qiymat chiqmaydi)")

    print("\n=== 3. B (takrorlar soni) ta'siri ===")
    x = rng.lognormal(3, 0.8, 200)
    for b in [100, 1_000, 10_000]:
        kengliklar = []
        for _ in range(20):
            q = np.mean(rng.choice(x, size=(b, len(x)), replace=True), axis=1)
            lo, hi = np.percentile(q, [2.5, 97.5])
            kengliklar.append(hi - lo)
        print(f"  B={b:>6}: CI kengligi {np.mean(kengliklar):.3f} ± {np.std(kengliklar):.3f}")
    print("  ⭐ Bootstrap — kuchli, lekin sehrli emas")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. O'rtacha uchun qamrov (log-normal, haqiqiy o'rtacha ma'lum) ===
  n= 10: qamrov 0.851  (maqsad 0.95)
  n= 30: qamrov 0.883  (maqsad 0.95)
  n=100: qamrov 0.926  (maqsad 0.95)
  n=400: qamrov 0.947  (maqsad 0.95)

=== 2. Maksimum uchun bootstrap ishlamaydi ===
  namuna maksimumi: 99.69
  bootstrap CI: [97.37, 99.69]
  haqiqiy maksimum 100 — CI uni o'z ichiga olmaydi (namunadan katta qiymat chiqmaydi)

=== 3. B (takrorlar soni) ta'siri ===
  B=   100: CI kengligi 7.320 ± 0.622
  B=  1000: CI kengligi 7.411 ± 0.242
  B= 10000: CI kengligi 7.419 ± 0.078
  ⭐ Bootstrap — kuchli, lekin sehrli emas

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
"Bootstrap ma'lumot yaratadi" Mavjud ma'lumotni qayta ishlatadi
"Bootstrap tarafkashlikni tuzatadi" Faqat namuna olish noaniqligi
"Har qanday statistika uchun ishlaydi" Maksimum/minimum — yo'q
"Sessiya darajasida bootstrap OK" Klaster (foydalanuvchi) bootstrap
"B = 100 yetarli" Kamida 2 000
"Permutatsiya = bootstrap" Test vs CI (turli maqsad)
"Kichik namunada ham ishonchli" n < 10-15 — ehtiyot
"Vaqt qatorida oddiy bootstrap" Blok bootstrap

6. Keng tarqalgan xatolar va yechimlari

1. Noto'g'ri birlik

python
rng.choice(sessiyalar, len(sessiyalar), replace=True)             # ⚠️
userlar = rng.choice(unikal_userlar, len(unikal_userlar), replace=True)  # ✅

2. Juftlashgan ma'lumotni buzish

python
stats.bootstrap((oldin, keyin), ...)          # mustaqil deb       # ⚠️
stats.bootstrap((oldin - keyin,), np.mean, ...)                   # ✅

3. Kichik B

python
B = 200                                                           # ⚠️
B = 10_000                                                        # ✅

4. random_state yo'q

python
stats.bootstrap((x,), np.median)                                  # ⚠️
stats.bootstrap((x,), np.median, random_state=0)                  # ✅

5. Sekin sikl

python
for i in range(10_000): boot[i] = np.median(rng.choice(x, len(x)))  # ⚠️
M = rng.choice(x, size=(10_000, len(x)), replace=True); np.median(M, axis=1)  # ✅

6. Test uchun CI, CI uchun test

python
# bootstrap CI dan p-qiymat "yasash"                              # ⚠️
stats.permutation_test(...)   # test uchun                         # ✅

7. Vaqt qatorida

python
rng.choice(kunlik_savdo, len(kunlik_savdo), replace=True)         # ⚠️
# blok bootstrap: ketma-ket bo'laklarni tanlash                    # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 9.1-dars (o'tilgan): Monte Carlo simulyatsiya
  • 11.4-dars (o'tilgan): Nisbiy farq CI muammosi
  • 11.7-dars (o'tilgan): Median va noparametrik yondashuv
  • 11.10-dars: A/B test loyihasi
  • Model baholash qismi: Metrikalar CI, modellarni solishtirish

8. Eng yaxshi amaliyotlar

  1. Qayta namuna — mustaqil birlik darajasida.

  2. CI uchun bootstrap, test uchun permutatsiya.

  3. B >= 2 000 (imkon bo'lsa 10 000).

  4. random_state bilan takrorlanuvchan.

  5. Vektorlashtiring (tezlik).

  6. Juftlashganda farqlar bilan ishlang.

  7. Cheklovlarni eslang (maksimum, vaqt qatori).

  8. Natijani biznes birligida bering.


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # bootstrap nima qiladi?
2.  # qaytarib tanlash nima uchun?
3.  # persentil CI qanday?
4.  # permutatsiya testi nima quradi?
5.  # p qanday hisoblanadi (permutatsiya)?
6.  # klaster bootstrapda birlik?
7.  # juftlashganda nima bootstrap qilinadi?
8.  # B minimal?
9.  # maksimum uchun bootstrap?
10. # vaqt qatorida?
11. # tanlov tarafkashligi tuzatiladimi?
12. # nisbiy o'sish CI uchun?
Javoblar
  1. Statistikaning taqsimotini tiklaydi
  2. Namuna olish tebranishini modellash
  3. [2.5, 97.5] kvantillari
  4. H0 taqsimotini
  5. Ekstremal statistikalar ulushi
  6. Foydalanuvchi (klaster)
  7. Farqlar
  8. ~2 000
  9. Ishlamaydi
  10. Blok bootstrap
  11. Yo'q
  12. Bootstrap

Vazifa 2: Xatolarni tuzating

python
1.  rng.choice(df["sessiya_vaqti"], len(df), replace=True)   # har user 10 sessiya

2.  stats.bootstrap((oldin, keyin), lambda a, b: a.mean() - b.mean())   # juftlashgan

3.  B = 150

4.  stats.bootstrap((x,), np.median)   # hisobot uchun

5.  for i in range(10_000): boot[i] = np.mean(rng.choice(x, len(x), replace=True))
Javoblar
python
1.  userlar = rng.choice(df["user_id"].unique(), n_user, replace=True)   # klaster bootstrap

2.  stats.bootstrap((oldin - keyin,), np.mean, random_state=0)

3.  B = 10_000

4.  stats.bootstrap((x,), np.median, random_state=0)

5.  M = rng.choice(x, size=(10_000, len(x)), replace=True); boot = M.mean(axis=1)

Vazifa 3: A/B to'liq hisobot

Modellang:

  1. Konversiya ma'lumoti
  2. Absolyut va nisbiy farq CI (bootstrap)
  3. Permutatsiya p-qiymati
  4. Menejer uchun 4 qatorli xulosa

Vazifa 4: Metrikalar CI

Modellang:

  1. Yuklanish vaqti (qiyshiq)
  2. Median, p90, p99 CI
  3. Ikki versiya farqi CI
  4. SLA qarori

Vazifa 5: Klaster bootstrap

Modellang:

  1. 200 foydalanuvchi × turli sessiya soni
  2. Sessiya va klaster bootstrap
  3. CI kengliklari
  4. Xulosa

Vazifa 6: Integratsiya

Modellang:

  1. Monte Carlo (9.1)
  2. Noparametrik test (11.7)
  3. Proporsiya CI (11.4)
  4. Hisobot (8.9)

Vazifa 7: O'ylash

Bootstrap ba'zan "statistikaning qora tanqidchisiz vositasi" deb ataladi: u formulalarsiz, farazlarsiz ishlaganday ko'rinadi. Nima uchun bu xavfli tasavvur? Bootstrap qanday savollarga javob bera olmaydi, va uning natijasini qanday tekshirish kerak?

Javob

Qisqa javob: bootstrap faqat namuna olish noaniqligini modellaydi — u namunangiz populyatsiyani vakillik qiladi deb faraz qiladi. Tarafkash namunada bootstrap CI ham tarafkash bo'ladi, faqat "ishonchli ko'rinishda". U o'lchov xatolari, tanlov tarafkashligi, chalkashtiruvchi omillar va model xatolarini tuzatmaydi.

1. Bootstrap nimani modellaydi va nimani yo'q

Modellaydi Modellamaydi
Namuna olish tebranishi Tanlov tarafkashligi
Statistikaning taqsimoti O'lchov xatosi
Murakkab statistikalar CI Sababiy xulosa
— Populyatsiya o'zgarishi (drift)

2. Yashirin farazlar

  • Kuzatuvlar mustaqil (yoki to'g'ri klaster darajasida)
  • Namuna populyatsiyaning tasodifiy vakili
  • Statistika "silliq" (maksimum emas)
  • n yetarlicha katta

3. Qanday tekshirish

  1. Simulyatsiya bilan qamrovni sinash (Misol 4)
  2. Klassik formula bor bo'lsa — solishtirish
  3. Turli B va usullar (persentil, BCa) natijasini taqqoslash
  4. Ma'lumot yig'ish jarayonini tekshirish (tarafkashlik manbalari)

4. Data Scientist qanday

  • Bootstrap CI ni "namuna olish noaniqligi" deb aniq nomlaydi
  • Tarafkashlik xavflarini hisobotda alohida yozadi (8.9)
  • Kichik namunada ehtiyotkor talqin qiladi

5. Xulosa

  1. Bootstrap — kuchli, lekin farazlari bor
  2. U faqat namuna olish noaniqligini beradi
  3. Tarafkashlik — alohida muammo
  4. Qamrovni simulyatsiya bilan tekshirish mumkin

Nimani mustahkamlaydi: 2.6, 2.7-bo'limlar.


Xulosa

Bu darsda bootstrap va permutatsiya testlarini o'rgandik.

Eng muhim uch fikr:

  1. Bootstrap — universal CI. Namunadan qaytarib qayta namunalar olib, har qanday statistikaning (median, persentil, nisbiy o'sish, korrelyatsiya, model metrikasi) taqsimotini va ishonch oralig'ini quradi. scipy.stats.bootstrap (BCa) yoki qo'lda persentil usuli; B >= 2 000, random_state bilan.

  2. Permutatsiya — universal test. Guruh yorliqlarini aralashtirib, H0 dunyosini ma'lumotdan quradi: p = kuzatilgandan ekstremalroq natijalar ulushi. permutation_type: "independent" (mustaqil guruhlar), "samples" (juftlashgan), "pairings" (bog'liqlik).

  3. To'g'ri birlik va cheklovlar. Qayta namuna mustaqil birlik darajasida (klaster bootstrap — foydalanuvchilar; juftlashganda — farqlar). Bootstrap sehr emas: kichik namunada, maksimum/minimum uchun, bog'liq ma'lumotda (vaqt qatori) ishlamaydi va tanlov tarafkashligini tuzatmaydi.

Keyingi darsda ko'p taqqoslash muammosini o'rganamiz: nima uchun ko'p test yolg'on kashfiyotlar keltiradi, Bonferroni va FDR tuzatishlari, hamda amaliy tavsiyalar.

Gipoteza testlari · 8-dars yakunlandi

11.8-dars: Bootstrap va permutatsiya

17 daqvaqt
0belgi
Keyingi dars: 11.9-dars: Ko'p taqqoslash muammosi
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0