ROC, PR, threshold va nomutanosib ma'lumot

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression

df = pd.read_csv(DATA / "uy_ijara.csv")
son = ["xonalar", "maydon_m2", "qavat", "qavatlar_soni", "metro_km", "mebel", "qurilgan_yil"]
X, y = df[son + ["tuman"]], df["ijaraga_berildi_30k"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

quvur = Pipeline([
    ("tayyorla", ColumnTransformer([
        ("son", Pipeline([("toldir", SimpleImputer(strategy="median")),
                          ("shkala", StandardScaler())]), son),
        ("matn", OneHotEncoder(handle_unknown="ignore"), ["tuman"]),
    ])),
    ("model", LogisticRegression(max_iter=2000)),
]).fit(X_tr, y_tr)

ehtimol = quvur.predict_proba(X_te)[:, 1]
taqqos = pd.DataFrame({"ehtimollik": ehtimol.round(3), "predict()": quvur.predict(X_te),
                       "haqiqat": y_te.values}).head(8)
show(taqqos)

from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score

print(f"{'chegara':>8} {'precision':>10} {'recall':>8} {'F1':>7} {'accuracy':>9} {'nechta ha':>10}")
print("-" * 56)
for t in [0.3, 0.4, 0.5, 0.6, 0.7, 0.8]:
    b = (ehtimol >= t).astype(int)
    print(f"{t:>8} {precision_score(y_te, b, zero_division=0):>10.4f} "
          f"{recall_score(y_te, b, zero_division=0):>8.4f} "
          f"{f1_score(y_te, b, zero_division=0):>7.4f} "
          f"{accuracy_score(y_te, b):>9.4f} {int(b.sum()):>10}")

import numpy as np
kerakli = None
for t in np.arange(0.30, 0.96, 0.01):
    b = (ehtimol >= t).astype(int)
    if b.sum() > 0 and precision_score(y_te, b, zero_division=0) >= 0.85:
        kerakli = t
        break
b = (ehtimol >= kerakli).astype(int)
print(f"Eng past chegara (precision >= 0.85): {kerakli:.2f}")
print(f"  precision: {precision_score(y_te, b):.4f}")
print(f"  recall   : {recall_score(y_te, b):.4f}")
print(f"  model nechta 'ha' dedi: {int(b.sum())} ta (0.5 da {int((ehtimol >= 0.5).sum())} ta edi)")

from sklearn.metrics import precision_recall_curve
prec, rec, thr = precision_recall_curve(y_te, ehtimol)
f1_egri = 2 * prec * rec / np.maximum(prec + rec, 1e-12)
eng = int(np.nanargmax(f1_egri[:-1]))
print(f"Eng yaxshi F1 beradigan chegara: {thr[eng]:.3f}  ->  F1 = {f1_egri[eng]:.4f}")
print(f"Sukut bo'yicha 0.5 da          :          F1 = {f1_score(y_te, quvur.predict(X_te)):.4f}")

np.random.seed(42)
tez = y_te[y_te == 1].index
sekin = y_te[y_te == 0].index
tanlov = list(sekin) + list(np.random.choice(tez, size=max(1, int(len(sekin) * 0.02)), replace=False))

y_nom = y_te.loc[tanlov]
e_nom = pd.Series(ehtimol, index=y_te.index).loc[tanlov].values
print(f"Yangi to'plam: {len(y_nom)} qator, 'tez ketdi' ulushi {y_nom.mean():.2%}")

from sklearn.metrics import roc_auc_score, average_precision_score

auc = roc_auc_score(y_nom, e_nom)
ap = average_precision_score(y_nom, e_nom)

print(f"ROC-AUC          : {auc:.4f}")
print(f"Average Precision: {ap:.4f}")
print()
print("Tasodifiy model uchun baza:")
print(f"  ROC-AUC = 0.5000      (HAR DOIM, nomutanosiblikdan qat'i nazar)")
print(f"  AP      = {y_nom.mean():.4f}      (= pozitiv sinf ulushi)")

b_nom = (e_nom >= 0.5).astype(int)
from sklearn.metrics import confusion_matrix
tn, fp, fn, tp = confusion_matrix(y_nom, b_nom).ravel()
print(f"TN={tn}  FP={fp}  FN={fn}  TP={tp}")
print()
print("ROC ning ikkinchi o'qi — FPR:")
print(f"  FPR = FP / (FP + TN) = {fp} / ({fp} + {tn}) = {fp/(fp+tn):.4f}")
print()
print("TN ulkan (negativlar ko'p) -> maxraj ulkan -> FPR doim kichik.")
print("Natijada ROC egri chizig'i chap yuqoriga yopishadi va CHIROYLI ko'rinadi.")
print()
print("PR egri chizig'i esa TN ni UMUMAN ishlatmaydi:")
print(f"  precision = TP / (TP + FP) = {tp} / ({tp} + {fp}) = {tp/(tp+fp) if tp+fp else 0:.4f}")
print(f"  recall    = TP / (TP + FN) = {tp} / ({tp} + {fn}) = {tp/(tp+fn) if tp+fn else 0:.4f}")

import matplotlib.pyplot as plt
from sklearn.metrics import roc_curve

fpr, tpr, _ = roc_curve(y_nom, e_nom)
p2, r2, _ = precision_recall_curve(y_nom, e_nom)

rasm, axes = plt.subplots(1, 2, figsize=(13, 5))
axes[0].plot(fpr, tpr, "b-", lw=2, label=f"AUC = {auc:.3f}")
axes[0].plot([0, 1], [0, 1], "k--", alpha=.5, label="Tasodifiy (0.5)")
axes[0].set_xlabel("False Positive Rate"); axes[0].set_ylabel("True Positive Rate")
axes[0].set_title("ROC — CHIROYLI ko'rinadi", color="darkorange", fontweight="bold")
axes[0].legend(); axes[0].grid(alpha=.3)

axes[1].plot(r2, p2, "r-", lw=2, label=f"AP = {ap:.3f}")
axes[1].axhline(y_nom.mean(), color="k", ls="--", alpha=.5, label=f"Tasodifiy ({y_nom.mean():.3f})")
axes[1].set_xlabel("Recall"); axes[1].set_ylabel("Precision")
axes[1].set_title("PR — HAQIQATNI ko'rsatadi", color="green", fontweight="bold")
axes[1].legend(); axes[1].grid(alpha=.3)
fig("roc_pr.png", caption="Bir xil model, bir xil ma'lumot. Chapdagi grafik sizni aldaydi.")

tz = list(set(tanlov))
X_nom = X_te.loc[tz]
y_nom2 = y_te.loc[tz]
X_ntr, X_nte, y_ntr, y_nte = train_test_split(X_nom, y_nom2, test_size=0.4,
                                              random_state=42, stratify=y_nom2)

def oz_quvur(**kw):
    return Pipeline([
        ("tayyorla", ColumnTransformer([
            ("son", Pipeline([("toldir", SimpleImputer(strategy="median")),
                              ("shkala", StandardScaler())]), son),
            ("matn", OneHotEncoder(handle_unknown="ignore"), ["tuman"]),
        ])),
        ("model", LogisticRegression(max_iter=3000, **kw)),
    ])

oddiy = oz_quvur().fit(X_ntr, y_ntr)
balans = oz_quvur(class_weight="balanced").fit(X_ntr, y_ntr)

qatorlar = []
for nom_m, m in [("Oddiy", oddiy), ("class_weight=balanced", balans)]:
    b = m.predict(X_nte)
    qatorlar.append({"Model": nom_m,
                     "Accuracy": round(accuracy_score(y_nte, b), 4),
                     "Precision": round(precision_score(y_nte, b, zero_division=0), 4),
                     "Recall": round(recall_score(y_nte, b, zero_division=0), 4),
                     "F1": round(f1_score(y_nte, b, zero_division=0), 4)})
show(pd.DataFrame(qatorlar))

from sklearn.metrics import classification_report
print(classification_report(y_nte, oddiy.predict(X_nte),
                            target_names=["sekin", "tez"], digits=4, zero_division=0))

show(pd.DataFrame([
    {"Tushuncha": "predict() ichida 0.5 bor", "Bitta jumla": "U matematik haqiqat emas, sukut qiymat"},
    {"Tushuncha": "Threshold surish", "Bitta jumla": "Qayta o'qitmasdan precision/recall tanlovi"},
    {"Tushuncha": "Chegara oshsa", "Bitta jumla": "Precision o'sadi, recall tushadi — har doim"},
    {"Tushuncha": "ROC-AUC", "Bitta jumla": "Teng sinflarda yaxshi; nomutanosibda ALDAYDI (TN sababli)"},
    {"Tushuncha": "PR-AUC (AP)", "Bitta jumla": "TN ni ishlatmaydi — nomutanosibda haqiqatni aytadi"},
    {"Tushuncha": "class_weight=balanced", "Bitta jumla": "Tuzatish emas, tarozini og'dirish"},
    {"Tushuncha": "macro vs weighted", "Bitta jumla": "Nomutanosibda macro ni o'qi"},
]))