"""Ders 05 — Lojistik regresyon ve sınıflandırma ölçütleri.

Çelik bir kolonun eğilmeli burkulmasını sınıflandırma problemi olarak kuruyoruz. Girdiler boyutsuz
narinlik λ̄ ve kullanım oranı n = N_Ed/(A·f_y); çıktı "yetersiz" (1) ya da "yeterli" (0).

Veri sentetiktir. Azaltma katsayısı χ(λ̄), EN 1993-1-1 §6.3.1.2'deki formülle burkulma eğrisi b
(α = 0.34) için hesaplanır. Sanal "deney sonucu", n > χ(λ̄)·R ise yetersizdir. R, ortancası 1 ve
logaritmik standart sapması 0.10 olan lognormal bir dayanım saçılımıdır. Bu bir varsayımdır;
gerçek kolon deneylerindeki saçılımı tam temsil etmez. Tasarımda yönetmelik kontrolü kullanılır,
bu model değil: amaç sınıflandırmayı öğrenmektir.

Çalıştır:  python d05_lojistik_regresyon.py
Gerekenler: numpy, scipy, scikit-learn, matplotlib  (Python 3.12+)
Çıktılar:  terminale sayılar, aynı klasöre üç PNG grafiği
"""
from pathlib import Path

import numpy as np
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from scipy.stats import norm
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (accuracy_score, average_precision_score, brier_score_loss, confusion_matrix,
                             f1_score, log_loss, precision_recall_curve, precision_score, recall_score,
                             roc_auc_score, roc_curve)
from sklearn.model_selection import StratifiedKFold, cross_val_predict, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler

# --- Grafik stili (kurs genelinde aynı) ---
RENK = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6", "#e34948"]
MUREKKEP, IKINCIL, SOLUK = "#0b0b0b", "#52514e", "#898781"
plt.rcParams.update({
    "figure.facecolor": "white", "axes.facecolor": "white", "savefig.facecolor": "white",
    "axes.edgecolor": "#c3c2b7", "axes.labelcolor": IKINCIL, "axes.titlecolor": MUREKKEP,
    "axes.titlesize": 11, "axes.titleweight": "bold", "axes.labelsize": 10,
    "xtick.color": IKINCIL, "ytick.color": IKINCIL, "font.size": 10,
    "axes.grid": True, "grid.color": "#e1e0d9", "grid.linewidth": 0.6,
    "axes.spines.top": False, "axes.spines.right": False,
    "axes.prop_cycle": plt.cycler(color=RENK), "lines.linewidth": 2, "legend.frameon": False,
})
KLASOR = Path(__file__).resolve().parent


def chi(lam, alfa=0.34):
    """EN 1993-1-1 azaltma katsayısı: Φ = 0.5[1 + α(λ̄ − 0.2) + λ̄²], χ = 1/(Φ + √(Φ² − λ̄²)) ≤ 1."""
    phi = 0.5 * (1 + alfa * (lam - 0.2) + lam**2)
    return np.minimum(1.0, 1.0 / (phi + np.sqrt(phi**2 - lam**2)))


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


# %% 1. Veri: sanal kolon deneyleri
rng = np.random.default_rng(42)
N = 600
SIGMA_R = 0.10                                   # ln R'nin standart sapması (varsayım)
lam = rng.uniform(0.2, 2.5, N)                   # boyutsuz narinlik λ̄
n = rng.uniform(0.05, 1.2, N)                    # kullanım oranı N_Ed/(A·f_y)
R = rng.lognormal(0.0, SIGMA_R, N)               # dayanım saçılımı, ortanca 1
y = (n > chi(lam) * R).astype(int)               # 1 = yetersiz (burkuldu), 0 = yeterli
X = np.column_stack([lam, n])
X_eg, X_te, y_eg, y_te = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)
u_eg = X_eg[:, 1] / chi(X_eg[:, 0])              # fizik özelliği u = n/χ(λ̄)
u_te = X_te[:, 1] / chi(X_te[:, 0])
print("=== 1. Veri ===")
print(f"Örnek: {N} (eğitim {len(y_eg)}, test {len(y_te)}), yetersiz oranı: {y.mean():.3f}")
print("χ kontrolü (eğri b): " + ", ".join(f"λ̄={v:.1f} → {chi(v):.4f}" for v in (0.5, 1.0, 2.0, 2.5)))

# %% 2. Sıfırdan gradyan inişi ve scikit-learn (ham özellikler λ̄, n; standartlaştırılmış)
ort, ss = X_eg.mean(axis=0), X_eg.std(axis=0)
A = np.column_stack([(X_eg - ort) / ss, np.ones(len(y_eg))])   # son sütun: kesişim için birler


def bce(w, A, y):
    """Ortalama ikili çapraz entropi; log(1 + e^t) − y·t biçimi taşmaya karşı kararlıdır."""
    t = A @ w
    return np.mean(np.logaddexp(0.0, t) - y * t)


def lojistik_gd(A, y, ogrenme_hizi, adim):
    w = np.zeros(A.shape[1])
    for _ in range(adim):
        p = sigmoid(A @ w)
        w -= ogrenme_hizi * A.T @ (p - y) / len(y)    # ∇L = Xᵀ(p − y)/m, m = örnek sayısı
    return w


L_egrilik = np.linalg.eigvalsh(A.T @ A / len(y_eg)).max() / 4   # Hessyen ≤ XᵀX/(4m)
w_gd = lojistik_gd(A, y_eg, ogrenme_hizi=4.0, adim=5000)
skl = LogisticRegression(C=1e6, tol=1e-8, max_iter=1000).fit(A[:, :2], y_eg)  # C büyük: cezasız gibi
w_skl = np.r_[skl.coef_[0], skl.intercept_]
w_ham = w_gd[:2] / ss                                              # ham birimlere geri çevir
b_ham = w_gd[2] - np.sum(w_gd[:2] * ort / ss)
print("\n=== 2. Sıfırdan gradyan inişi ve scikit-learn ===")
print(f"Eğrilik üst sınırı λmax(XᵀX/m)/4 = {L_egrilik:.3f} → η = 4 güvenli (η < {2 / L_egrilik:.2f})")
print(f"GD (η=4, 5000 adım)    : w = [{w_gd[0]:.4f}, {w_gd[1]:.4f}], b = {w_gd[2]:.4f}, "
      f"kayıp = {bce(w_gd, A, y_eg):.5f}")
print(f"sklearn (C=1e6, lbfgs) : w = [{w_skl[0]:.4f}, {w_skl[1]:.4f}], b = {w_skl[2]:.4f}, "
      f"kayıp = {bce(w_skl, A, y_eg):.5f}, {skl.n_iter_[0]} iterasyon")
print(f"En büyük katsayı farkı: {np.abs(w_gd - w_skl).max():.1e}")
print(f"Doğrusal karar sınırı (ham birimler): n = {-b_ham / w_ham[1]:.3f} − {w_ham[0] / w_ham[1]:.3f}·λ̄")
assert np.abs(w_gd - w_skl).max() < 1e-3

# %% 3. Özellik mühendisliği: aynı algoritma, üç farklı özellik kümesi
model_A = make_pipeline(StandardScaler(), LogisticRegression(C=1e6, tol=1e-8)).fit(X_eg, y_eg)
model_B = make_pipeline(PolynomialFeatures(2, include_bias=False), StandardScaler(),
                        LogisticRegression(C=1e6, tol=1e-8, max_iter=5000)).fit(X_eg, y_eg)
model_C = LogisticRegression(C=1e6, tol=1e-8).fit(u_eg.reshape(-1, 1), y_eg)
p_A = model_A.predict_proba(X_te)[:, 1]
p_B = model_B.predict_proba(X_te)[:, 1]
p_C = model_C.predict_proba(u_te.reshape(-1, 1))[:, 1]
p_gercek = norm.cdf(np.log(u_te) / SIGMA_R)       # veriyi üreten olasılık P(R < u)
u_yildiz = -model_C.intercept_[0] / model_C.coef_[0, 0]
print("\n=== 3. Özellik seçimi: üç model (test kümesi) ===")
print("Model                          doğruluk  log-kayıp    AUC")
for ad, p in [("(A) λ̄, n doğrusal", p_A), ("(B) λ̄, n 2. derece polinom", p_B),
              ("(C) fizik özelliği u = n/χ", p_C), ("(*) gerçek olasılık P(R < u)", p_gercek)]:
    print(f"{ad:31s} {accuracy_score(y_te, p >= 0.5):6.3f}   {log_loss(y_te, p):7.4f}  "
          f"{roc_auc_score(y_te, p):.4f}")
print(f"(C) katsayılar: w = {model_C.coef_[0, 0]:.2f}, b = {model_C.intercept_[0]:.2f} → "
      f"sınır u* = {u_yildiz:.3f} (gerçek: 1)")
assert np.allclose(model_A[-1].coef_[0], w_skl[:2], rtol=1e-3)

# %% 4. Sınıflandırma ölçütleri: model C, eşik 0.5, test kümesi
tahmin = (p_C >= 0.5).astype(int)
tn, fp, fn, tp = confusion_matrix(y_te, tahmin).ravel()
print("\n=== 4. Ölçütler (model C, eşik 0.5, test) ===")
print(f"Karışıklık matrisi: TN = {tn}, FP = {fp}, FN = {fn}, TP = {tp}")
print(f"Doğruluk {accuracy_score(y_te, tahmin):.3f}, kesinlik {precision_score(y_te, tahmin):.3f}, "
      f"duyarlılık {recall_score(y_te, tahmin):.3f}, F1 {f1_score(y_te, tahmin):.3f}")
print(f"ROC AUC {roc_auc_score(y_te, p_C):.4f}, ortalama kesinlik (PR) "
      f"{average_precision_score(y_te, p_C):.4f}, log-kayıp {log_loss(y_te, p_C):.4f}, "
      f"Brier {brier_score_loss(y_te, p_C):.4f}")
assert tp + fn == y_te.sum() and tn + fp + fn + tp == len(y_te)

# %% 5. Maliyete göre eşik: kaçan göçme (FN) yanlış alarmın (FP) 20 katı
MALIYET_FN, MALIYET_FP = 20.0, 1.0
kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
p_oof = cross_val_predict(LogisticRegression(C=1e6, tol=1e-8), u_eg.reshape(-1, 1), y_eg, cv=kfold,
                          method="predict_proba")[:, 1]   # her örnek, görmediği katın modeliyle


def maliyet(y_gercek, p, esik):
    t = p >= esik
    fn_ = int(np.sum((y_gercek == 1) & ~t))
    fp_ = int(np.sum((y_gercek == 0) & t))
    return fn_, fp_, (MALIYET_FN * fn_ + MALIYET_FP * fp_) / len(y_gercek)


esikler = np.round(np.arange(0.01, 0.991, 0.005), 3)
maliyetler = np.array([maliyet(y_eg, p_oof, e)[2] for e in esikler])
esik_iyi = esikler[np.argmin(maliyetler)]
print("\n=== 5. Maliyete göre eşik (FN = 20 × FP; eğitim kümesi, 5 katlı CV tahminleri) ===")
print("eşik    FN   FP   maliyet/örnek  duyarlılık  kesinlik")
for e in sorted({0.5, 0.3, 0.2, 0.1, 0.05, 0.02, float(esik_iyi)}, reverse=True):
    fn_, fp_, c = maliyet(y_eg, p_oof, e)
    t = p_oof >= e
    print(f"{e:5.3f}  {fn_:3d}  {fp_:3d}   {c:8.3f}        {recall_score(y_eg, t):.3f}      "
          f"{precision_score(y_eg, t):.3f}" + ("   ← en düşük maliyet" if e == esik_iyi else ""))
print(f"Kuramsal eşik (kalibre olasılık için): 1/(1+20) = {1 / 21:.3f}")
for e in (0.5, esik_iyi):
    fn_, fp_, c = maliyet(y_te, p_C, e)
    print(f"Test, eşik {e:.3f}: FN = {fn_}, FP = {fp_}, maliyet/örnek = {c:.3f}")

# %% 6. Sınıf dengesizliği: çoğu yönetmeliğe göre boyutlandırılmış 2000 kolon
M = 2000
u_tas = rng.uniform(0.30, 1.05, M)                 # tasarım kullanım oranı n/χ
y_tas = (u_tas > rng.lognormal(0.0, SIGMA_R, M)).astype(int)
u1, u2, y1, y2 = train_test_split(u_tas.reshape(-1, 1), y_tas, test_size=0.3, random_state=42,
                                  stratify=y_tas)
print("\n=== 6. Sınıf dengesizliği (tasarlanmış 2000 kolon) ===")
print(f"Yetersiz oranı: {y_tas.mean():.3f}; u > 1 olan kolon: {np.sum(u_tas > 1)}; "
      f"test kümesi: {len(y2)} kolon, {y2.sum()} yetersiz")
hep_sifir = np.zeros_like(y2)                      # her kolona "yeterli" diyen tembel model
print(f"'Hepsi yeterli' tahmini     : doğruluk {accuracy_score(y2, hep_sifir):.3f}, "
      f"duyarlılık {recall_score(y2, hep_sifir):.3f}")
for ad, cw in [("Lojistik, ağırlıksız", None), ("Lojistik, class_weight='balanced'", "balanced")]:
    m = LogisticRegression(C=1e6, tol=1e-8, class_weight=cw).fit(u1, y1)
    t = m.predict(u2)
    print(f"{ad:34s}: doğruluk {accuracy_score(y2, t):.3f}, duyarlılık {recall_score(y2, t):.3f}, "
          f"kesinlik {precision_score(y2, t):.3f}, sınır u* = {-m.intercept_[0] / m.coef_[0, 0]:.3f}")

# %% 7. Grafikler
# Şekil 1: veri ve 0.5 karar sınırları; u ekseninde sigmoid
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].scatter(X_eg[y_eg == 0, 0], X_eg[y_eg == 0, 1], s=14, facecolors="none", edgecolors=SOLUK, lw=0.8)
ax[0].scatter(X_eg[y_eg == 1, 0], X_eg[y_eg == 1, 1], s=14, marker="x", color=SOLUK, lw=0.8)
LL, NN = np.meshgrid(np.linspace(0.2, 2.5, 300), np.linspace(0.0, 1.25, 300))
izgara = np.column_stack([LL.ravel(), NN.ravel()])
p_iz_C = model_C.predict_proba((izgara[:, 1] / chi(izgara[:, 0])).reshape(-1, 1))[:, 1]
for p_iz, renk in [(model_A.predict_proba(izgara)[:, 1], RENK[1]),
                   (model_B.predict_proba(izgara)[:, 1], RENK[2]), (p_iz_C, RENK[0])]:
    ax[0].contour(LL, NN, p_iz.reshape(LL.shape), levels=[0.5], colors=[renk], linewidths=2)
ll = np.linspace(0.2, 2.5, 200)
ax[0].plot(ll, chi(ll), color=MUREKKEP, ls="--", lw=1.4)
tutamak = [Line2D([], [], marker="o", ls="none", mfc="none", mec=SOLUK, label="Yeterli (eğitim)"),
           Line2D([], [], marker="x", ls="none", color=SOLUK, label="Yetersiz (eğitim)"),
           Line2D([], [], color=RENK[1], label="(A) doğrusal sınır"),
           Line2D([], [], color=RENK[2], label="(B) 2. derece polinom"),
           Line2D([], [], color=RENK[0], label="(C) u = n/χ özelliği"),
           Line2D([], [], color=MUREKKEP, ls="--", lw=1.4, label="Gerçek sınır n = χ(λ̄)")]
ax[0].legend(handles=tutamak, loc="upper center", ncol=2, fontsize=8)   # üstteki boş şeritte
ax[0].set(xlabel="Boyutsuz narinlik λ̄", ylabel="Kullanım oranı n = N/(A·fy)", ylim=(0, 1.6),
          yticks=np.arange(0, 1.21, 0.2), title="Karar sınırları (p = 0.5)")
uu = np.linspace(0.02, 2.5, 300)
titresim = rng.uniform(-0.03, 0.03, len(y_eg))
ax[1].scatter(u_eg, y_eg + titresim, s=10, color=SOLUK, alpha=0.6, label="Eğitim verisi (0/1, titretilmiş)")
ax[1].plot(uu, model_C.predict_proba(uu.reshape(-1, 1))[:, 1], color=RENK[0], label="(C) lojistik model")
ax[1].plot(uu, norm.cdf(np.log(uu) / SIGMA_R), color=MUREKKEP, ls="--", lw=1.4, label="Gerçek olasılık")
ax[1].axvline(1.0, color=IKINCIL, ls=":", lw=1.2)
ax[1].set(xlim=(0, 2.5), xlabel="u = n/χ(λ̄)", ylabel="P(yetersiz)", title="Fizik özelliği boyunca sigmoid")
ax[1].legend(loc="center right", fontsize=8)
fig.savefig(KLASOR / "d05_lojistik_regresyon_1.png", dpi=160)
plt.close(fig)

# Şekil 2: ROC ve kesinlik–duyarlılık eğrileri (test)
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for ad, p, renk in [("(A) doğrusal", p_A, RENK[1]), ("(B) polinom", p_B, RENK[2]),
                    ("(C) u özelliği", p_C, RENK[0])]:
    fpr, tpr, _ = roc_curve(y_te, p)
    ax[0].plot(fpr, tpr, color=renk, drawstyle="steps-post",
               label=f"{ad}: AUC = {roc_auc_score(y_te, p):.3f}")
    kes, duy, _ = precision_recall_curve(y_te, p)
    ax[1].plot(duy, kes, color=renk, drawstyle="steps-post",
               label=f"{ad}: ort. kesinlik = {average_precision_score(y_te, p):.3f}")
for e, isaret in [(0.5, "o"), (esik_iyi, "s")]:
    t = p_C >= e
    ax[0].plot(np.mean(t[y_te == 0]), np.mean(t[y_te == 1]), marker=isaret, ms=8, mfc="white",
               mec=MUREKKEP, ls="none", label=f"(C) eşik {e:.3f}")
ax[0].set(xlim=(-0.01, 0.4), ylim=(0.6, 1.01), xlabel="Yanlış alarm oranı FP/(FP+TN)",
          ylabel="Duyarlılık TP/(TP+FN)", title="ROC eğrisi (yakınlaştırılmış)")
ax[0].legend(loc="lower right", fontsize=8)
ax[1].set(xlim=(0.6, 1.01), ylim=(0.6, 1.01), xlabel="Duyarlılık", ylabel="Kesinlik TP/(TP+FP)",
          title="Kesinlik–duyarlılık eğrisi (yakınlaştırılmış)")
ax[1].legend(loc="lower left", fontsize=8)
fig.savefig(KLASOR / "d05_lojistik_regresyon_2.png", dpi=160)
plt.close(fig)

# Şekil 3: eşiğe göre beklenen maliyet, kesinlik ve duyarlılık (eğitim, CV tahminleri)
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].plot(esikler, maliyetler, color=RENK[0], drawstyle="steps-post", label="Beklenen maliyet (CV)")
ax[0].axvline(1 / 21, color=MUREKKEP, ls="--", lw=1.2, label="Kuramsal eşik 1/21")
ax[0].axvline(0.5, color=IKINCIL, ls=":", lw=1.2, label="Varsayılan eşik 0.5")
ax[0].plot(esik_iyi, maliyetler.min(), marker="*", ms=13, color=MUREKKEP, ls="none",
           label=f"En düşük maliyet: eşik {esik_iyi:.3f}")
ax[0].set(xscale="log", xlabel="Eşik (log ölçek)", ylabel="Maliyet / örnek (FP = 1 birim)",
          title="FN = 20 × FP iken eşik seçimi")
ax[0].legend(loc="upper left", fontsize=8, frameon=True, framealpha=1, edgecolor="white")
tahminler = p_oof[None, :] >= esikler[:, None]             # her satır bir eşik
tp_e = (tahminler & (y_eg == 1)).sum(axis=1)
duy_e = tp_e / y_eg.sum()
kes_e = tp_e / tahminler.sum(axis=1)
ax[1].plot(esikler, duy_e, color=RENK[0], drawstyle="steps-post", label="Duyarlılık")
ax[1].plot(esikler, kes_e, color=RENK[1], drawstyle="steps-post", label="Kesinlik")
ax[1].axvline(esik_iyi, color=MUREKKEP, ls="--", lw=1.2, label=f"Seçilen eşik {esik_iyi:.3f}")
ax[1].set(xscale="log", xlabel="Eşik (log ölçek)", ylabel="Oran", ylim=(0.80, 1.005),
          title="Eşik düşerken duyarlılık artar, kesinlik düşer")
ax[1].legend(loc="lower center", ncol=3, fontsize=8, frameon=True, framealpha=1, edgecolor="white")
fig.savefig(KLASOR / "d05_lojistik_regresyon_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d05_lojistik_regresyon_1.png, _2.png, _3.png")
