Logistic regression

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

df = pd.read_csv(DATA / "uy_ijara.csv")
son = ["xonalar", "maydon_m2", "qavat", "qavatlar_soni", "metro_km", "mebel"]
X, y = df[son], 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)

chiziqli = LinearRegression().fit(X_tr, y_tr)
b = chiziqli.predict(X_te)

print(f"Target faqat 0 yoki 1: {sorted(y.unique().tolist())}")
print()
print(f"Chiziqli model bashoratlari:")
print(f"  eng kichik : {b.min():.4f}")
print(f"  eng katta  : {b.max():.4f}")
print()
print(f"0 dan KICHIK bashoratlar: {int((b < 0).sum())} ta")
print(f"1 dan KATTA bashoratlar : {int((b > 1).sum())} ta")

import matplotlib.pyplot as plt

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

print(f"{'z':>8} {'sigmoid(z)':>12}   izoh")
print("-" * 46)
for z in [-6, -2, -1, 0, 1, 2, 6]:
    s = sigmoid(z)
    izoh = "0 ga yopishadi" if s < 0.05 else ("1 ga yopishadi" if s > 0.95 else
           ("AYNAN o'rtada" if z == 0 else "o'rta zona"))
    print(f"{z:>8} {s:>12.6f}   {izoh}")

z = np.linspace(-8, 8, 300)
rasm, axes = plt.subplots(1, 2, figsize=(13.5, 4.6))

axes[0].plot(z, sigmoid(z), "b-", lw=2.5)
axes[0].axhline(0.5, color="gray", ls=":", lw=1)
axes[0].axvline(0, color="gray", ls=":", lw=1)
axes[0].axhline(0, color="red", ls="--", lw=1, alpha=.6)
axes[0].axhline(1, color="red", ls="--", lw=1, alpha=.6)
axes[0].set_xlabel("z = x @ w + b"); axes[0].set_ylabel("sigmoid(z) = ehtimollik")
axes[0].set_title("Sigmoid — 0 va 1 orasida QOLADI", fontweight="bold")
axes[0].grid(alpha=.3)

axes[1].scatter(X_te.maydon_m2, y_te, alpha=.3, s=25, label="haqiqat (0/1)", color="#5f6368")
tartib = np.argsort(X_te.maydon_m2.to_numpy())
axes[1].plot(X_te.maydon_m2.to_numpy()[tartib], b[tartib], "r-", lw=2, label="chiziqli (chegaradan chiqadi)")
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
log_bir = Pipeline([("sc", StandardScaler()), ("m", LogisticRegression())]).fit(X_tr[["maydon_m2"]], y_tr)
e_bir = log_bir.predict_proba(X_te[["maydon_m2"]])[:, 1]
axes[1].plot(X_te.maydon_m2.to_numpy()[tartib], e_bir[tartib], "g-", lw=2.5, label="logistic (0-1 ichida)")
axes[1].axhline(0, color="k", ls=":", lw=.8); axes[1].axhline(1, color="k", ls=":", lw=.8)
axes[1].set_xlabel("maydon_m2"); axes[1].set_ylabel("ehtimollik")
axes[1].set_title("Ikki model yonma-yon", fontweight="bold")
axes[1].legend(fontsize=8.5); axes[1].grid(alpha=.3)
fig("sigmoid.png", caption="Chapda sigmoid funksiyasi. O'ngda: qizil chiziq 0 dan pastga va 1 dan yuqoriga chiqadi, yashil chiziq esa chegarada qoladi.")

def log_loss_bitta(p, y):
    p = np.clip(p, 1e-15, 1 - 1e-15)
    return -(y * np.log(p) + (1 - y) * np.log(1 - p))

print("Haqiqat y=1 bo'lganda, model turli ehtimollik bersa:")
print(f"{'bashorat p':>12} {'MSE jarima':>13} {'log loss jarima':>18}")
print("-" * 46)
for p in [0.9, 0.7, 0.5, 0.3, 0.1, 0.01]:
    print(f"{p:>12} {(p - 1)**2:>13.4f} {log_loss_bitta(p, 1):>18.4f}")

quvur = Pipeline([("sc", StandardScaler()), ("m", LogisticRegression(max_iter=2000))]).fit(X_tr, y_tr)
k = quvur.named_steps["m"].coef_[0]

jadval = pd.DataFrame({
    "xususiyat": son,
    "koeffitsiyent (log-odds)": k.round(4),
    "odds ratio (e^k)": np.exp(k).round(4),
}).assign(talqin=lambda d: [
    f"1 std oshsa, odds {abs(v-1)*100:.1f}% {'oshadi' if v > 1 else 'kamayadi'}"
    for v in d["odds ratio (e^k)"]
])
show(jadval.sort_values("koeffitsiyent (log-odds)", key=abs, ascending=False))

print("Odds va ehtimollik orasidagi aloqa:")
print(f"{'ehtimollik':>12} {'odds':>10} {'log-odds':>11}")
print("-" * 36)
for p in [0.1, 0.25, 0.5, 0.75, 0.9]:
    odds = p / (1 - p)
    print(f"{p:>12} {odds:>10.3f} {np.log(odds):>11.3f}")
print()
print("p = 0.5 da odds = 1 va log-odds = 0 -> sigmoid ning markazi")

from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.model_selection import cross_val_score

pg = pd.read_csv(DATA / "penguins.csv")
pson = ["bill_length_mm", "bill_depth_mm", "flipper_length_mm", "body_mass_g"]
pmatn = ["island", "sex"]
Xp, yp = pg[pson + pmatn], pg["species"]

def p_quvur(**kw):
    return Pipeline([
        ("t", ColumnTransformer([
            ("son", Pipeline([("i", SimpleImputer(strategy="median")), ("sc", StandardScaler())]), pson),
            ("matn", Pipeline([("i", SimpleImputer(strategy="most_frequent")),
                               ("o", OneHotEncoder(handle_unknown="ignore"))]), pmatn),
        ])),
        ("m", LogisticRegression(max_iter=3000, **kw)),
    ])

for nom, kw in [("multinomial (softmax)", {}), ("one-vs-rest", {"multi_class": "ovr"})]:
    try:
        bb = cross_val_score(p_quvur(**kw), Xp, yp, cv=5, scoring="f1_macro")
        print(f"  {nom:24s} macro F1 = {bb.mean():.4f} ±{bb.std():.4f}")
    except Exception as e:
        print(f"  {nom:24s} {type(e).__name__}")

mp = p_quvur().fit(Xp, yp)
print("Sinflar:", mp.named_steps["m"].classes_.tolist())
print("Koeffitsiyentlar shakli:", mp.named_steps["m"].coef_.shape,
      "-> har SINF uchun alohida koeffitsiyent to'plami")
print()
e = mp.predict_proba(Xp.head(4))
print("Birinchi 4 pingvin uchun ehtimolliklar (har qator yig'indisi = 1):")
print(pd.DataFrame(e.round(4), columns=mp.named_steps["m"].classes_).to_string(index=False))
print()
print("Yig'indilar:", e.sum(axis=1).round(6).tolist())

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

ehtimol = quvur.predict_proba(X_te)[:, 1]
print(f"{'chegara':>9} {'precision':>11} {'recall':>8} {'F1':>7}")
print("-" * 38)
for t in [0.3, 0.5, 0.7]:
    bb = (ehtimol >= t).astype(int)
    print(f"{t:>9} {precision_score(y_te, bb, zero_division=0):>11.4f} "
          f"{recall_score(y_te, bb, zero_division=0):>8.4f} {f1_score(y_te, bb, zero_division=0):>7.4f}")
print()
print("Shuning uchun logistic regression amalda qulay: u ehtimollik beradi,")
print("va siz chegarani biznes talabiga qarab tanlaysiz (8-bob).")

show(pd.DataFrame([
    {"Afzalligi": "Ehtimollik beradi", "Nega muhim": "Chegarani surish mumkin (8-bob)"},
    {"Afzalligi": "Tushuntiriladi", "Nega muhim": "Odds ratio — bank, tibbiyot talab qiladi"},
    {"Afzalligi": "Tez va arzon", "Nega muhim": "Millionlab qator bilan ham ishlaydi"},
    {"Afzalligi": "Kam overfitting", "Nega muhim": "Oddiy model, kam parametr"},
    {"Kamchiligi": "Faqat CHIZIQLI chegara", "Nega muhim": "Murakkab naqshni ko'rmaydi -> daraxt (17-bob)"},
    {"Kamchiligi": "Scaling kerak", "Nega muhim": "Gradient va regularizatsiya uchun"},
    {"Kamchiligi": "Xususiyatlarni o'zi yaratmaydi", "Nega muhim": "Qo'lda feature engineering kerak (22-bob)"},
]))

from sklearn.tree import DecisionTreeClassifier

# sun'iy "halqa" naqshi: chiziqli chegara bilan ajratib bo'lmaydi
r = np.random.default_rng(42)
n = 600
burchak = r.uniform(0, 2 * np.pi, n)
radius = np.where(r.random(n) < 0.5, r.normal(1, .25, n), r.normal(3, .3, n))
Xh = np.c_[radius * np.cos(burchak), radius * np.sin(burchak)]
yh = (radius > 2).astype(int)

for nom, m in [("Logistic Regression", LogisticRegression()),
               ("Decision Tree", DecisionTreeClassifier(max_depth=6, random_state=42))]:
    bb = cross_val_score(Pipeline([("sc", StandardScaler()), ("m", m)]), Xh, yh, cv=5)
    print(f"  {nom:22s} accuracy = {bb.mean():.4f} ±{bb.std():.4f}")
print()
print("Halqa shaklidagi ma'lumotda chiziqli chegara ishlamaydi.")
print("17-bobda daraxt shunday naqshni qanday ushlashini ko'ramiz.")

show(pd.DataFrame([
    {"Tushuncha": "Muammo", "Bitta jumla": "Chiziqli model 0-1 dan chiqib ketadi"},
    {"Tushuncha": "Sigmoid", "Bitta jumla": "Har qanday sonni [0,1] ga siqadi"},
    {"Tushuncha": "Model", "Bitta jumla": "sigmoid(x @ w + b) — 11-bobdagi amal + bitta funksiya"},
    {"Tushuncha": "Log loss", "Bitta jumla": "Ishonchli xatoni qattiq jazolaydi; kosani qavariq qiladi"},
    {"Tushuncha": "Koeffitsiyent", "Bitta jumla": "log-odds; exp(k) = odds ko'paytuvchisi"},
    {"Tushuncha": "Multiclass", "Bitta jumla": "Softmax — har sinfga ehtimollik, yig'indi = 1"},
    {"Tushuncha": "Cheklovi", "Bitta jumla": "Faqat chiziqli chegara — halqani ajratmaydi"},
]))