Tarmoqni baholash

import numpy as np


def chalkashlik(haqiqiy, bashorat):
    """Ikkilik tasniflash uchun chalkashlik matritsasi."""
    tp = int(((bashorat == 1) & (haqiqiy == 1)).sum())
    tn = int(((bashorat == 0) & (haqiqiy == 0)).sum())
    fp = int(((bashorat == 1) & (haqiqiy == 0)).sum())
    fn = int(((bashorat == 0) & (haqiqiy == 1)).sum())
    return {"TP": tp, "TN": tn, "FP": fp, "FN": fn}


def olchovlar(haqiqiy, bashorat):
    m = chalkashlik(haqiqiy, bashorat)
    tp, tn, fp, fn = m["TP"], m["TN"], m["FP"], m["FN"]
    aniqlik = (tp + tn) / max(1, tp + tn + fp + fn)
    precision = tp / max(1, tp + fp)
    recall = tp / max(1, tp + fn)
    f1 = 2 * precision * recall / max(1e-12, precision + recall)
    return {"aniqlik": aniqlik, "precision": precision,
            "recall": recall, "f1": f1}


def kasallik_malumoti(n=1000, urug=0):
    """1% kasal - kuchli nomutanosib to'plam."""
    gen = np.random.default_rng(urug)
    kasal = gen.uniform(0, 1, n) < 0.01
    belgi = gen.normal(0, 1, n) + kasal * 2.5
    return belgi.reshape(-1, 1), kasal.astype(float).reshape(-1, 1)


def kop_sinfli_matritsa(haqiqiy, bashorat, sinflar):
    m = np.zeros((sinflar, sinflar), dtype=int)
    for h, b in zip(haqiqiy, bashorat):
        m[int(h), int(b)] += 1
    return m


def sinf_bo_yicha(M):
    sinflar = M.shape[0]
    natija = []
    for k in range(sinflar):
        tp = M[k, k]
        fp = M[:, k].sum() - tp
        fn = M[k, :].sum() - tp
        p = tp / max(1, tp + fp)
        r = tp / max(1, tp + fn)
        f1 = 2 * p * r / max(1e-12, p + r)
        natija.append((k, int(tp), int(fp), int(fn), p, r, f1))
    return natija

X, y = kasallik_malumoti(1000)
print("kasallar soni:", int(y.sum()), "/", len(y))

dangasa = np.zeros_like(y)          # "hech kim kasal emas"
m = olchovlar(y, dangasa)
print("'hech kim kasal emas' modeli:")
for nom, qiymat in m.items():
    print(f"  {nom:<10} {qiymat:.4f}")

haqiqiy = np.array([1, 1, 1, 1, 0, 0, 0, 0, 0, 0]).reshape(-1, 1)
bashorat = np.array([1, 1, 0, 0, 1, 0, 0, 0, 0, 0]).reshape(-1, 1)

m = chalkashlik(haqiqiy, bashorat)
print("chalkashlik matritsasi:", m)
o = olchovlar(haqiqiy, bashorat)
for nom, qiymat in o.items():
    print(f"{nom:<10} {qiymat:.4f}")

def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))


X, y = kasallik_malumoti(2000, urug=1)
ehtimollik = sigmoid(2.0 * X - 3.0)      # oddiy model o'rniga

print("chegara  TP  FP  FN  precision  recall     F1")
for chegara in [0.1, 0.2, 0.3, 0.5, 0.7, 0.9]:
    bashorat = (ehtimollik > chegara).astype(float)
    m = chalkashlik(y, bashorat)
    o = olchovlar(y, bashorat)
    print(f"{chegara:>6}  {m['TP']:>3} {m['FP']:>3} {m['FN']:>3}  "
          f"{o['precision']:>8.4f}  {o['recall']:>6.4f}  {o['f1']:>6.4f}")

holatlar = [(1.0, 0.0), (0.9, 0.1), (0.5, 0.5), (0.7, 0.6)]
print("precision  recall   oddiy o'rtacha    F1")
for p, r in holatlar:
    oddiy = (p + r) / 2
    f1 = 0.0 if p + r == 0 else 2 * p * r / (p + r)
    print(f"{p:>9.2f}  {r:>6.2f}   {oddiy:>13.3f}  {f1:>6.3f}")

def kop_sinfli_matritsa(haqiqiy, bashorat, sinflar):
    m = np.zeros((sinflar, sinflar), dtype=int)
    for h, b in zip(haqiqiy, bashorat):
        m[int(h), int(b)] += 1
    return m


gen = np.random.default_rng(0)
haqiqiy = gen.integers(0, 3, 300)
bashorat = haqiqiy.copy()
xato_indeks = gen.choice(300, 60, replace=False)
bashorat[xato_indeks] = (bashorat[xato_indeks] + 1) % 3

M = kop_sinfli_matritsa(haqiqiy, bashorat, 3)
print("        bashorat")
print("        0    1    2")
for i in range(3):
    print(f"haq {i}  {M[i, 0]:>4} {M[i, 1]:>4} {M[i, 2]:>4}")
print("umumiy aniqlik:", round(float(np.trace(M) / M.sum()), 4))

def sinf_bo_yicha(M):
    sinflar = M.shape[0]
    natija = []
    for k in range(sinflar):
        tp = M[k, k]
        fp = M[:, k].sum() - tp
        fn = M[k, :].sum() - tp
        p = tp / max(1, tp + fp)
        r = tp / max(1, tp + fn)
        f1 = 2 * p * r / max(1e-12, p + r)
        natija.append((k, int(tp), int(fp), int(fn), p, r, f1))
    return natija


gen = np.random.default_rng(0)
haqiqiy = gen.integers(0, 3, 300)
bashorat = haqiqiy.copy()
xato_indeks = gen.choice(300, 60, replace=False)
bashorat[xato_indeks] = (bashorat[xato_indeks] + 1) % 3
M = kop_sinfli_matritsa(haqiqiy, bashorat, 3)

print("sinf   TP  FP  FN  precision  recall      F1")
for k, tp, fp, fn, p, r, f1 in sinf_bo_yicha(M):
    print(f"{k:>4}  {tp:>3} {fp:>3} {fn:>3}  {p:>8.4f}  {r:>6.4f}  {f1:>6.4f}")

def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))


class Tarmoq:
    def __init__(self, olchamlar, urug=42):
        gen = np.random.default_rng(urug)
        self.q = len(olchamlar) - 1
        self.W = [gen.normal(0, np.sqrt(2.0 / olchamlar[i]),
                             (olchamlar[i], olchamlar[i + 1])) for i in range(self.q)]
        self.b = [np.zeros(olchamlar[i + 1]) for i in range(self.q)]

    def oldinga(self, X):
        A = X
        kesh = {"A0": X}
        for i in range(self.q):
            Z = A @ self.W[i] + self.b[i]
            A = sigmoid(Z) if i == self.q - 1 else np.maximum(0.0, Z)
            kesh[f"Z{i+1}"] = Z
            kesh[f"A{i+1}"] = A
        return A, kesh

    def qadam(self, X, y, tezlik):
        A, kesh = self.oldinga(X)
        dZ = (A - y) / len(y)
        for i in range(self.q - 1, -1, -1):
            dW = kesh[f"A{i}"].T @ dZ
            db = dZ.sum(axis=0)
            if i > 0:
                dZ = (dZ @ self.W[i].T) * (kesh[f"Z{i}"] > 0)
            self.W[i] -= tezlik * dW
            self.b[i] -= tezlik * db


gen = np.random.default_rng(0)
X = gen.normal(0, 1, (400, 6))
y = ((X[:, 0] * X[:, 1] + X[:, 2]) > 0).astype(float).reshape(-1, 1)
Xo, yo, Xt, yt = X[:280], y[:280], X[280:], y[280:]

natijalar = []
for urug in range(8):
    t = Tarmoq([6, 16, 1], urug=urug)
    for _ in range(1500):
        t.qadam(Xo, yo, 0.3)
    A, _ = t.oldinga(Xt)
    natijalar.append(float(((A > 0.5).astype(float) == yt).mean()))

n = np.array(natijalar)
print("har urug' uchun aniqlik:", np.round(n, 4))
print(f"o'rtacha: {n.mean():.4f}  std: {n.std():.4f}")
print(f"eng past: {n.min():.4f}  eng yuqori: {n.max():.4f}")

gen = np.random.default_rng(0)
ehtimollik = gen.uniform(0, 1, 2000)
# haqiqiy natija ehtimollikka mos keladi - ya'ni model KALIBRLANGAN
haqiqiy = (gen.uniform(0, 1, 2000) < ehtimollik).astype(float)

print("ishonch      namunalar  haqiqiy ulush")
for past, yuqori in [(0.0, 0.2), (0.2, 0.4), (0.4, 0.6), (0.6, 0.8), (0.8, 1.0)]:
    tanlov = (ehtimollik >= past) & (ehtimollik < yuqori)
    if tanlov.sum() > 0:
        print(f"{past:.1f} - {yuqori:.1f}   {int(tanlov.sum()):>8}  "
              f"{float(haqiqiy[tanlov].mean()):>13.3f}")