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

9.9-dars: Ehtimollik va ML

9-QISM — EHTIMOLLIK · 9-dars

1. Kirish va motivatsiya

Bu qismda ehtimollik tilini, shartli ehtimollik va Bayes'ni, tasodifiy o'zgaruvchi va taqsimotlarni o'rgandik. Endi savol: bularning hammasi Machine Learning'da qayerda? Javob — hamma joyda. ML modeli — ma'lumotdan taqsimot o'rganuvchi mashina: regressiya P(y | x) ning o'rtachasini, klassifikator P(sinf | x) ni baholaydi; model o'qitish — maksimal ishonchlilik; xato funksiyasi (log-loss) — manfiy log-ishonchlilik; predict_proba — shartli ehtimol; Naive Bayes — Bayes teoremasi.

Bu dars ML qismlariga ko'prik: ishonchlilik (likelihood) va maksimal ishonchlilik bahosi (MLE) — parametr qanday "o'rganiladi"; log-loss — nima uchun klassifikatorlar aynan shu xatoni minimallashtiradi; predict_proba va chegara — ehtimoldan qarorga; kalibrlash — model aytgan "70%" haqiqatan 70% mi; Naive Bayes sklearn'da. Bularni tushungan odam ML modellarini "qora quti" emas, ehtimollik modeli sifatida ko'radi.

Real vaziyat. Bank kredit modeli mijoz uchun "defolt ehtimoli 0.3" beradi. Risk bo'limi so'raydi: "Bu 0.3 ga ishonsa bo'ladimi? 0.3 deb baholangan 1000 mijozdan haqiqatan ~300 tasi defolt qiladimi?". Data Scientist kalibrlash egri chizig'ini chizadi: model 0.3 deganlar orasida haqiqiy defolt 0.18 ekan — model "qo'rqoq" (ehtimollarni oshirib yuboradi). Chegara 0.5 bo'lgani uchun aniqlik (accuracy) yaxshi edi, lekin ehtimollar asosida foiz stavka belgilanganda bank yaxshi mijozlarni yo'qotayotgan edi. Kalibrlash (Platt/isotonic) — muammoni hal qildi.

Bu darsda ehtimollik va ML aloqasini o'rganamiz.

Bu darsda:

  • Ishonchlilik (likelihood) va MLE
  • Log-ishonchlilik va log-loss
  • predict_proba — shartli ehtimol
  • Chegara (threshold) va kutilgan narx
  • Kalibrlash
  • Naive Bayes (sklearn)
  • Ehtimollik-ML tuzoqlari
  • Amaliy: ehtimolli klassifikator tahlili

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

2. Nazariya — chuqur tushuntirish

2.1. Ishonchlilik (likelihood) va MLE

text
Ehtimol:       parametr ma'lum → ma'lumot qanchalik ehtimolli?   P(ma'lumot | p)
Ishonchlilik:  ma'lumot ma'lum → qaysi parametr ko'proq mos?     L(p) = P(ma'lumot | p)

Tanga: 10 tashlashda 7 gerb
  L(p) = p^7 × (1 - p)^3
  L0.5-bob = 0.00098,  L0.7-bob = 0.00222  ← 0.7 ko'proq mos
  MLE: L ni maksimal qiluvchi p = 7/10 = 0.7

Ishonchlilik L(parametr) — bir xil formula (P(ma'lumot | parametr)), lekin qarash yo'nalishi teskari: ma'lumot qotirilgan, parametr o'zgaradi. Maksimal ishonchlilik bahosi (MLE) — ma'lumotni eng ehtimolli qiladigan parametr. Natijalar ko'pincha intuitiv: Bernulli uchun MLE — ulush; normal uchun — namuna o'rtachasi va SD (ddof=0); Poisson uchun — o'rtacha. 9.8-darsdagi dist.fit() — MLE. ML o'qitish — xuddi shu: model parametrlarini (og'irliklar) ma'lumot ishonchliligini maksimal qiladigan qilib tanlash.

2.2. Log-ishonchlilik va log-loss

text
Mustaqil kuzatuvlar: L = P(y1) × P(y2) × ... × P(yn)   ← juda kichik son (underflow)
Log-ishonchlilik:    log L = sum( log P(yi) )           ← yig'indi, barqaror

Binar klassifikatsiya, model p_i = P(y_i = 1 | x_i) beradi:
  log L = sum( y_i × log(p_i) + (1 - y_i) × log(1 - p_i) )

LOG-LOSS (binar cross-entropy) = - log L / n     ← minimallashtiriladi
  y = 1, p = 0.9 → -log(0.9) = 0.105   (yaxshi)
  y = 1, p = 0.1 → -log(0.1) = 2.303   (qattiq jazo — ishonchli xato)

Log-loss — manfiy o'rtacha log-ishonchlilik: log-loss ni minimallashtirish = ishonchlilikni maksimallashtirish (MLE). Logistik regressiya, neyron tarmoqlar (cross-entropy) — aynan shu. Xususiyati: ishonch bilan xato qilishni qattiq jazolaydi (p = 0.01 da y = 1 → 4.6), noaniq bashorat 0.5-bob — o'rtacha 0.693-bob. Shuning uchun log-loss ehtimollar sifatini o'lchaydi, accuracy esa faqat chegaradan keyingi to'g'ri/noto'g'rini. Regressiyada MSE — normal taqsimotli xato farazi ostidagi MLE.

2.3. predict_proba — shartli ehtimol

model.predict_proba(X) — har qator uchun P(sinf | belgilar) 9.3-bob: har qatorda yig'indi 1 (aksioma, 9.1); ikki sinfda [:, 1] — musbat sinf ehtimoli. model.predict(X) — ehtimolni chegara (odatda 0.5) bilan qarorga aylantiradi. Ehtimol — qarordan boy ma'lumot: 0.51 va 0.99 ikkalasi ham "1", lekin ishonch darajasi turlicha. Reyting (kimga birinchi qo'ng'iroq qilish), xavf baholash, narxlash — ehtimol bilan ishlaydi. Ehtimol shartli: o'quv ma'lumoti taqsimoti (asosiy ulush, 9.4) o'zgarsa, ehtimollar ham siljiydi.

2.4. Chegara (threshold) va kutilgan narx

text
Qaror: p >= chegara → "musbat"

Kutilgan narx 9.6-bob:
  E[narx] = P(FP) × narx(FP) + P(FN) × narx(FN)

Firibgarlik: FN (o'tkazib yuborish) = 1 000 000 so'm, FP (tekshiruv) = 20 000 so'm
  Optimal chegara ≈ narx(FP) / (narx(FP) + narx(FN)) ≈ 0.02   (kalibrlangan p uchun)

Chegara 0.5 — qonun emas: xato turlarining narxi teng bo'lganda optimal. Narxlar farq qilsa (firibgarlik, kasallik, churn), optimal chegara — kutilgan narxni minimallashtiruvchi: kalibrlangan ehtimol uchun t = narx(FP) / (narx(FP) + narx(FN)). Amalda: chegaralar bo'yicha kutilgan narx (yoki foyda) egri chizig'i va minimum. Precision/recall muvozanati (Klassifikatsiya qismi) — shu tanlovning boshqa ko'rinishi. Formula faqat kalibrlangan ehtimollarda ishlaydi.

2.5. Kalibrlash

Kalibrlash — model aytgan ehtimolning haqiqatga mosligi: "0.7" deb baholangan holatlarning ~70% ida hodisa ro'y berishi kerak. Tekshirish: calibration_curve(y, p, n_bins=10) — har bin uchun o'rtacha bashorat va haqiqiy ulush; diagonalda — kalibrlangan. Brier score — (p - y)^2 o'rtachasi (kichik — yaxshi). Ko'p modellar kalibrlanmagan: Naive Bayes (mustaqillik farazi — ekstremal ehtimollar), daraxt ansambllari (0 va 1 dan qochadi), SVM (ehtimol bermaydi). Tuzatish: CalibratedClassifierCV (sigmoid — Platt, isotonic) — alohida ma'lumotda. Kalibrlash accuracy'ni o'zgartirmasligi mumkin, lekin ehtimolga asoslangan qarorlarni (narx, xavf, chegara) to'g'rilaydi.

2.6. Naive Bayes (sklearn)

Naive Bayes — Bayes teoremasi 9.4-bob + shartli mustaqillik farazi: P(sinf | x) ~ P(sinf) × P(x1 | sinf) × ... × P(xk | sinf). Turlari: GaussianNB (uzluksiz belgilar — har sinfda normal, 9.8), MultinomialNB (so'z sanoqlari — spam, matn), BernoulliNB (0/1 belgilar). Afzalliklari: juda tez, kam ma'lumotda ishlaydi, yaxshi baza (baseline). Kamchiligi: mustaqillik farazi buzilsa (bog'liq belgilar — bir xil so'zning ikki shakli), ehtimollar haddan tashqari ishonchli (0 yoki 1 ga yaqin) — kalibrlash kerak; lekin reyting (tartib) ko'pincha yaxshi qoladi.

2.7. Ehtimollik-ML tuzoqlari

Asosiy tuzoqlar: predict_proba ni haqiqiy ehtimol deb (kalibrlanmagan bo'lishi mumkin — tekshiring); 0.5 chegarani ko'r-ko'rona (xato narxlari farq qiladi); accuracy bilan ehtimol sifatini baholash (log-loss, Brier kerak); asosiy ulush o'zgarishi (o'quvda 50/50 balanslangan, ishlab chiqarishda 1% — ehtimollar siljigan, 9.4); kalibrlashni o'quv ma'lumotida (overfitting — alohida qism kerak); log(0) (log-loss'da p = 0 yoki 1 → cheksiz; sklearn qirqadi — clip); likelihood'ni ehtimol deb (L(p) — p ning taqsimoti emas, integral 1 emas); Naive Bayes ehtimollariga ishonish (tartib yaxshi, qiymat — yo'q).

2.8. Ehtimollik va ML — ko'prik

ML — ehtimollik modeli: MLE (ma'lumotni eng ehtimolli qiluvchi parametr; fit va model o'qitish); log-ishonchlilik (yig'indi, barqaror) → log-loss (klassifikatsiya xatosi; ishonchli xatoni jazolaydi); predict_proba — P(sinf | x), shartli ehtimol; chegara — kutilgan narx bo'yicha 9.6-bob, 0.5 emas; kalibrlash (calibration_curve, Brier, CalibratedClassifierCV); Naive Bayes — Bayes + mustaqillik (Gaussian/Multinomial/Bernoulli). Bog'lanishlar: 9.1 (aksiomalar — yig'indi 1), 9.3 (shartli), 9.4 (Bayes, asosiy ulush), 9.6 (kutilgan narx), 9.8 (fit), ML qismlari (logistik regressiya, klassifikatsiya metrikalari).

3. Tez ma'lumotnoma

python
import numpy as np
from sklearn.metrics import log_loss, brier_score_loss
from sklearn.calibration import calibration_curve, CalibratedClassifierCV
from sklearn.naive_bayes import GaussianNB, MultinomialNB, BernoulliNB

# MLE (Bernulli): ulush
p_hat = y.mean()

# LOG-LOSS qo'lda
eps = 1e-15; p = np.clip(p, eps, 1 - eps)
-np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
log_loss(y, p)                                   # bir xil

# EHTIMOL VA QAROR
proba = model.predict_proba(X_test)[:, 1]
qaror = proba >= chegara                         # 0.5 shart emas

# KALIBRLASH
haqiqiy, bashorat = calibration_curve(y_test, proba, n_bins=10)   # prob_true, prob_pred
brier_score_loss(y_test, proba)
kal = CalibratedClassifierCV(model, method="isotonic", cv=5).fit(X_train, y_train)
QOIDA: MLE = fit · log-loss = -log L · proba — kalibrlangani tekshir · chegara — narxdan

Ehtimollik va ML xulosasi

Likelihood L(theta) = P(ma'lumot | theta); MLE — maksimal L
Log-loss = -o'rtacha log L; ishonchli xatoni qattiq jazolaydi
predict_proba — P(sinf | x); predict — chegara bilan qaror
Chegara — kutilgan narxdan (FP va FN narxi)
Kalibrlash — calibration_curve, Brier, CalibratedClassifierCV
Naive Bayes — Bayes + mustaqillik; ehtimollar ekstremal

4. Batafsil misollar

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

Misol 1 — Ishonchlilik va MLE

python
"""Likelihood va MLE: tanga va Poisson (real numpy/scipy)."""

import numpy as np
from scipy import stats


def main() -> None:
    print("=== 1. Tanga: 10 dan 7 gerb ===")
    for p in [0.3, 0.5, 0.7, 0.9]:
        L = p ** 7 * (1 - p) ** 3
        print(f"  L({p}) = {L:.5f}")

    print("\n=== 2. MLE — setka bo'yicha qidiruv ===")
    p_setka = np.linspace(0.01, 0.99, 99)
    logL = 7 * np.log(p_setka) + 3 * np.log(1 - p_setka)
    print(f"  eng yaxshi p = {p_setka[logL.argmax()]:.2f}  (7/10)")

    print("\n=== 3. Poisson: MLE = o'rtacha ===")
    rng = np.random.default_rng(0)
    x = rng.poisson(4.2, 500)
    lam_setka = np.linspace(3, 5.5, 251)
    logL = [stats.poisson(l).logpmf(x).sum() for l in lam_setka]
    print(f"  MLE (setka): {lam_setka[int(np.argmax(logL))]:.2f}, o'rtacha: {x.mean():.2f}")

    print("\n=== 4. Normal fit = MLE ===")
    y = rng.normal(50, 8, 1000)
    mu, sd = stats.norm.fit(y)
    print(f"  fit: mu={mu:.3f}, sd={sd:.3f}; mean={y.mean():.3f}, std(ddof=0)={y.std():.3f}")
    print("  ⭐ MLE — ma'lumotni eng ehtimolli qiluvchi parametr")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Tanga: 10 dan 7 gerb ===
  L0.3-bob = 0.00008
  L0.5-bob = 0.00098
  L0.7-bob = 0.00222
  L0.9-bob = 0.00048

=== 2. MLE — setka bo'yicha qidiruv ===
  eng yaxshi p = 0.70  (7/10)

=== 3. Poisson: MLE = o'rtacha ===
  MLE (setka): 4.09, o'rtacha: 4.09

=== 4. Normal fit = MLE ===
  fit: mu=49.971, sd=8.137; mean=49.971, std(ddof=0)=8.137
  ⭐ MLE — ma'lumotni eng ehtimolli qiluvchi parametr

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Log-loss va accuracy

python
"""Log-loss: ehtimol sifati; accuracy bir xil bo'lsa ham farq (real numpy/sklearn)."""

import numpy as np
from sklearn.metrics import accuracy_score, log_loss


def main() -> None:
    y = np.array([1, 1, 1, 0, 0, 0, 1, 0])

    modellar = {
        "ishonchli to'g'ri": np.array([0.95, 0.9, 0.85, 0.1, 0.05, 0.15, 0.9, 0.1]),
        "ikkilanuvchi":      np.array([0.6, 0.55, 0.6, 0.4, 0.45, 0.4, 0.55, 0.45]),
        "bitta ishonchli xato": np.array([0.95, 0.9, 0.85, 0.1, 0.05, 0.15, 0.01, 0.1]),
    }

    print("=== 1. Accuracy va log-loss ===")
    for nom, p in modellar.items():
        acc = accuracy_score(y, p >= 0.5)
        print(f"  {nom:<22}: accuracy {acc:.3f}, log-loss {log_loss(y, p):.3f}")

    print("\n=== 2. Bitta kuzatuv jazosi (y = 1) ===")
    for p in [0.99, 0.9, 0.5, 0.1, 0.01]:
        print(f"  p = {p:<4}: -log(p) = {-np.log(p):.3f}")

    print("\n=== 3. Qo'lda = sklearn ===")
    p = modellar["ikkilanuvchi"]
    qolda = -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
    print(f"  qo'lda {qolda:.4f}, sklearn {log_loss(y, p):.4f}")
    print("  ⭐ Log-loss ehtimol sifatini o'lchaydi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Accuracy va log-loss ===
  ishonchli to'g'ri     : accuracy 1.000, log-loss 0.106
  ikkilanuvchi          : accuracy 1.000, log-loss 0.554
  bitta ishonchli xato  : accuracy 0.875, log-loss 0.669

=== 2. Bitta kuzatuv jazosi (y = 1) ===
  p = 0.99: -log(p) = 0.010
  p = 0.9 : -log(p) = 0.105
  p = 0.5 : -log(p) = 0.693
  p = 0.1 : -log(p) = 2.303
  p = 0.01: -log(p) = 4.605

=== 3. Qo'lda = sklearn ===
  qo'lda 0.5543, sklearn 0.5543
  ⭐ Log-loss ehtimol sifatini o'lchaydi

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Chegara va kutilgan narx

python
"""predict_proba va narxga asoslangan optimal chegara (real sklearn/numpy)."""

import numpy as np
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split


def main() -> None:
    X, y = make_classification(n_samples=20_000, n_features=8, weights=[0.95],
                               class_sep=1.0, random_state=0)
    X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.5, random_state=0, stratify=y)
    model = LogisticRegression(max_iter=1000).fit(X_tr, y_tr)
    p = model.predict_proba(X_te)[:, 1]

    print("=== 1. predict_proba ===")
    print(f"  birinchi 3 qator: {np.round(model.predict_proba(X_te[:3]), 3).tolist()}")
    print(f"  qator yig'indilari: {model.predict_proba(X_te[:3]).sum(axis=1).tolist()}")

    narx_fp, narx_fn = 20_000, 1_000_000
    print(f"\n=== 2. Kutilgan narx (FP={narx_fp:,}, FN={narx_fn:,}) ===")
    for t in [0.5, 0.2, 0.05, 0.02]:
        q = p >= t
        fp = ((q == 1) & (y_te == 0)).sum()
        fn = ((q == 0) & (y_te == 1)).sum()
        print(f"  chegara {t:<4}: FP={fp:>5}, FN={fn:>4}, narx={(fp * narx_fp + fn * narx_fn) / 1e6:7.1f} mln")

    print(f"\n=== 3. Nazariy chegara ===")
    print(f"  narx(FP) / (narx(FP) + narx(FN)) = {narx_fp / (narx_fp + narx_fn):.3f}")
    print("  ⭐ Chegara — xato narxidan, 0.5 emas")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. predict_proba ===
  birinchi 3 qator: [[0.99, 0.01], [0.999, 0.001], [0.999, 0.001]]
  qator yig'indilari: [1.0, 1.0, 1.0]

=== 2. Kutilgan narx (FP=20,000, FN=1,000,000) ===
  chegara 0.5 : FP=   27, FN= 377, narx=  377.5 mln
  chegara 0.2 : FP=  304, FN= 244, narx=  250.1 mln
  chegara 0.05: FP= 1851, FN= 123, narx=  160.0 mln
  chegara 0.02: FP= 3790, FN=  77, narx=  152.8 mln

=== 3. Nazariy chegara ===
  narx(FP) / (narx(FP) + narx(FN)) = 0.020
  ⭐ Chegara — xato narxidan, 0.5 emas

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

Misol 4 — Kalibrlash va Naive Bayes

python
"""Naive Bayes kalibrlanmagan ehtimollari va isotonic kalibrlash (real sklearn)."""

import numpy as np
from sklearn.calibration import CalibratedClassifierCV, calibration_curve
from sklearn.datasets import make_classification
from sklearn.metrics import brier_score_loss, roc_auc_score
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB


def main() -> None:
    X, y = make_classification(n_samples=30_000, n_features=20, n_informative=6,
                               n_redundant=10, random_state=1)
    X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.4, random_state=1)

    nb = GaussianNB().fit(X_tr, y_tr)
    kal = CalibratedClassifierCV(GaussianNB(), method="isotonic", cv=5).fit(X_tr, y_tr)

    for nom, m in [("GaussianNB", nb), ("NB + isotonic", kal)]:
        p = m.predict_proba(X_te)[:, 1]
        haqiqiy, bashorat = calibration_curve(y_te, p, n_bins=5)
        print(f"=== {nom} ===")
        print(f"  Brier: {brier_score_loss(y_te, p):.4f}, AUC: {roc_auc_score(y_te, p):.4f}")
        print(f"  ekstremal (p<0.01 yoki p>0.99): {((p < 0.01) | (p > 0.99)).mean():.1%}")
        for b, h in zip(bashorat, haqiqiy):
            print(f"    bashorat {b:.2f} → haqiqiy {h:.2f}")
        print()
    print("  ⭐ Reyting (AUC) yaxshi, ehtimol qiymati — kalibrlash bilan")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== GaussianNB ===
  Brier: 0.1138, AUC: 0.9369
  ekstremal (p<0.01 yoki p>0.99): 75.3%
    bashorat 0.01 → haqiqiy 0.11
    bashorat 0.29 → haqiqiy 0.47
    bashorat 0.49 → haqiqiy 0.49
    bashorat 0.71 → haqiqiy 0.59
    bashorat 0.99 → haqiqiy 0.89

=== NB + isotonic ===
  Brier: 0.0980, AUC: 0.9369
  ekstremal (p<0.01 yoki p>0.99): 13.1%
    bashorat 0.07 → haqiqiy 0.07
    bashorat 0.32 → haqiqiy 0.33
    bashorat 0.50 → haqiqiy 0.51
    bashorat 0.72 → haqiqiy 0.67
    bashorat 0.94 → haqiqiy 0.94

  ⭐ Reyting (AUC) yaxshi, ehtimol qiymati — kalibrlash bilan

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

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

Noto'g'ri fikr To'g'risi
"predict_proba — haqiqiy ehtimol" Kalibrlanganini tekshiring
"Chegara doim 0.5" Xato narxidan
"Accuracy yetarli" Ehtimol sifati — log-loss, Brier
"Likelihood — parametr ehtimoli" P(ma'lumot | parametr)
"Log-loss — shunchaki formula" Manfiy log-ishonchlilik (MLE)
"Naive Bayes ehtimollari aniq" Ekstremal; tartib yaxshi
"Kalibrlash — o'quv ma'lumotida" Alohida qism / CV
"Balanslangan o'quv — to'g'ri ehtimol" Asosiy ulush siljiydi

6. Keng tarqalgan xatolar va yechimlari

1. 0.5 chegara

python
qaror = model.predict(X)                                           # ⚠️
qaror = model.predict_proba(X)[:, 1] >= optimal_chegara            # ✅

2. Accuracy bilan ehtimol baholash

python
print(accuracy_score(y, p >= 0.5))                                 # ⚠️
print(log_loss(y, p), brier_score_loss(y, p))                      # ✅

3. log(0)

python
ll = -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))  # p=0 → inf # ⚠️
p = np.clip(p, 1e-15, 1 - 1e-15)                                   # ✅

4. Kalibrlashni o'quvda

python
CalibratedClassifierCV(model, cv="prefit").fit(X_train, y_train)   # ⚠️
CalibratedClassifierCV(model, cv=5).fit(X_train, y_train)          # ✅

5. calibration_curve tartibi

python
bashorat, haqiqiy = calibration_curve(y, p)                        # ⚠️
haqiqiy, bashorat = calibration_curve(y, p)   # prob_true, prob_pred # ✅

6. Likelihood ko'paytmasi

python
L = np.prod(stats.norm(mu, sd).pdf(x))       # underflow          # ⚠️
logL = stats.norm(mu, sd).logpdf(x).sum()                          # ✅

7. Balanslangan o'quvdan keyin

python
# o'quv 50/50 (oversampling), real 2% — proba to'g'ridan-to'g'ri  # ⚠️
# ehtimollarni real asosiy ulushga qayta kalibrlang                # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 9.3-9.4-darslar (o'tilgan): Shartli ehtimollik, Bayes
  • 9.6-dars (o'tilgan): Kutilgan narx
  • 9.8-dars (o'tilgan): fit — MLE
  • ML qismlari: Logistik regressiya, Naive Bayes, metrikalar
  • Model baholash qismi: Log-loss, Brier, ROC/AUC, kalibrlash

8. Eng yaxshi amaliyotlar

  1. Modelni ehtimollik modeli sifatida ko'ring.

  2. Ehtimol sifatini log-loss va Brier bilan o'lchang.

  3. Kalibrlash egri chizig'ini chizing.

  4. Kalibrlashni alohida ma'lumotda (CV) qiling.

  5. Chegarani xato narxidan tanlang.

  6. Log-ehtimollar bilan hisoblang.

  7. Naive Bayes — tez baza; ehtimollarini kalibrlang.

  8. Asosiy ulush o'zgarsa — qayta kalibrlang.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # likelihood nima?
2.  # 10 dan 7 gerb — MLE?
3.  # Poisson MLE?
4.  # log-loss (y=1, p=0.5)?
5.  # log-loss (y=1, p=0.01)?
6.  # predict_proba qator yig'indisi?
7.  # FP=1, FN=9 → optimal chegara?
8.  # kalibrlangan model "0.3" → haqiqiy?
9.  # Brier score — kichik yaxshimi?
10. # Naive Bayes "naive" nima?
11. # GaussianNB belgilarni qanday modellaydi?
12. # log-loss minimallashtirish = ?
Javoblar
  1. P(ma'lumot | parametr), parametr funksiyasi sifatida
  2. 0.7
  3. Namuna o'rtachasi
  4. 0.693
  5. 4.605
  6. 1
  7. 0.1
  8. ~30%
  9. Ha
  10. Belgilar shartli mustaqil deb faraz
  11. Har sinfda normal taqsimot
  12. MLE (ishonchlilikni maksimallashtirish)

Vazifa 2: Xatolarni tuzating

python
1.  qaror = model.predict(X)   # FN narxi FP dan 50 marta katta

2.  print(accuracy_score(y, p > 0.5))   # ehtimol sifati kerak

3.  L = np.prod(stats.norm(0, 1).pdf(x))   # n = 5000

4.  bashorat, haqiqiy = calibration_curve(y, p)

5.  -np.mean(y * np.log(p))   # log-loss
Javoblar
python
1.  qaror = model.predict_proba(X)[:, 1] >= 1 / 51

2.  print(log_loss(y, p), brier_score_loss(y, p))

3.  logL = stats.norm(0, 1).logpdf(x).sum()

4.  haqiqiy, bashorat = calibration_curve(y, p)

5.  -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))

Vazifa 3: MLE

Modellang:

  1. Eksponensial ma'lumot (kutish vaqtlari)
  2. Log-ishonchlilik funksiyasi (lambda setkasi)
  3. Maksimum
  4. 1 / o'rtacha bilan solishtirish

Vazifa 4: Chegara

Modellang:

  1. Churn modeli (LogisticRegression)
  2. Qolib qolish taklifi narxi va mijoz qiymati
  3. Chegaralar bo'yicha kutilgan foyda
  4. Optimal chegara

Vazifa 5: Kalibrlash

Modellang:

  1. RandomForest yoki GaussianNB
  2. calibration_curve (10 bin)
  3. Sigmoid va isotonic
  4. Brier va log-loss solishtirish

Vazifa 6: Integratsiya

Modellang:

  1. Bayes 9.4-bob → Naive Bayes
  2. Kutilgan narx 9.6-bob → chegara
  3. fit 9.8-bob → MLE
  4. Aksioma 9.1-bob → proba yig'indisi

Vazifa 7: O'ylash

Ob-havo xizmati "ertaga yomg'ir ehtimoli 70%" deydi. Ertaga yomg'ir yog'madi. Bashorat noto'g'ri bo'ldimi? Ehtimolli bashoratni bitta natija bilan baholash nima uchun mumkin emas, va ML modelining ehtimollarini qanday qilib halol baholash mumkin?

Javob

Qisqa javob: yo'q — 70% bashorat 30% holatda yomg'irsiz kun bo'lishini kutadi. Bitta natija ehtimolli bashoratni tasdiqlamaydi ham, rad etmaydi ham. Baholash — ko'p bashorat bo'yicha: "70%" deyilgan kunlarning ~70% ida yomg'ir yog'dimi (kalibrlash) va yomg'irli kunlarga yuqoriroq ehtimol berilganmi (ajratish qobiliyati).

1. Nega bitta natija yetmaydi

  • 70% — "10 ta shunday kunning ~7 tasida" degani
  • Yomg'irsiz kun — kutilgan 30% holatdan biri bo'lishi mumkin
  • Faqat natijaga qarab baholash — "natija xatosi" (outcome bias)

2. Halol baholash

Jihat Savol Vosita
Kalibrlash "70%" → ~70% ro'y beradimi? calibration_curve
Ajratish Hodisali holatlarga yuqori p? ROC AUC
Umumiy sifat Ikkalasi birga Log-loss, Brier

3. Ob-havo misoli

  • Ob-havo xizmatlari juda yaxshi kalibrlangan (o'nlab yillik ma'lumot)
  • Doim "30%" (iqlim o'rtachasi) degan xizmat — kalibrlangan, lekin foydasiz (ajratmaydi)
  • Yaxshi bashorat — ham kalibrlangan, ham keskin (0 ga va 1 ga yaqin, to'g'ri joyda)

4. Data Scientist qanday

  1. Ehtimolni bitta natija bilan baholamaydi
  2. Kalibrlash va ajratishni alohida o'lchaydi
  3. Log-loss/Brier bilan modellarni solishtiradi
  4. Menejerga "70% — kafolat emas" ekanini tushuntiradi

5. Xulosa

  1. Ehtimolli bashorat — ko'p holatda baholanadi
  2. Kalibrlash + ajratish — ikki alohida sifat
  3. Log-loss va Brier — ikkalasini birga o'lchaydi
  4. Natija xatosi — yaxshi qarorni omadsizlik uchun jazolash

Nimani mustahkamlaydi: 2.2, 2.5-bo'limlar.

Xulosa

Bu darsda ehtimollik va ML aloqasini o'rgandik.

Eng muhim uch fikr:

  1. O'qitish = MLE. Likelihood L(theta) = P(ma'lumot | theta) — parametr funksiyasi; MLE — ma'lumotni eng ehtimolli qiluvchi parametr (Bernulli — ulush, Poisson — o'rtacha, normal — mean va std; dist.fit). Log-ishonchlilik — yig'indi (barqaror); log-loss = manfiy o'rtacha log L — klassifikatorlar shuni minimallashtiradi; ishonchli xatoni qattiq jazolaydi.

  2. Ehtimoldan qarorga. predict_proba — P(sinf | x) (shartli, yig'indi 1); predict — chegara bilan. Optimal chegara — kutilgan narxdan: narx(FP) / (narx(FP) + narx(FN)), 0.5 emas — lekin faqat kalibrlangan ehtimollar uchun.

  3. Kalibrlash va Naive Bayes. Kalibrlash — "70%" haqiqatan ~70% mi (calibration_curve, Brier; tuzatish — CalibratedClassifierCV, alohida ma'lumotda). Naive Bayes — Bayes + shartli mustaqillik; tez va yaxshi baza, lekin ehtimollari ekstremal — reyting yaxshi, qiymat — kalibrlash bilan.

Keyingi darsda Ehtimollik amaliy loyihasi: Monte Carlo simulyatsiya bilan biznes masalasi — talab va zaxira modeli, taqsimot tanlash va fit, kutilgan foyda va xavf, optimal qaror — 9-qismning barcha bilimlari bitta loyihada.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
9.9-dars: Ehtimollik va ML — IlmHamroh