"""Ders 07 — Karar ağaçları.

Üç sentetik örnek kullanıyoruz:
1. Zemin sınıfı: (Vs)30, (N60)30 ve (cu)30'dan TBDY 2018 yerel zemin sınıfları (ZA–ZE).
   Etiketler yalnız (Vs)30 eşiklerinden gelir (180, 360, 760, 1500 m/s); N60 ve cu, Vs30'a
   gürültülü ve uydurma bağıntılarla bağlıdır (gerçek bir korelasyon değildir). Ağacın
   tablodaki eşikleri geri bulup bulmadığına bakıyoruz.
2. Regresyon: katmanlı bir zemin profilinde kayma dalgası hızı–derinlik ölçümleri (sentetik).
   Derinlik sınırlı regresyon ağacını NumPy ile sıfırdan kurup scikit-learn ile karşılaştırıyoruz.
3. Dış değer: basit kirişin orta açıklık sehimi δ = 5qL⁴/(384EI); eğitim açıklığı 2–6 m,
   tahmin 9 m'ye kadar.

Çalıştır:  python d07_karar_agaclari.py
Gerekenler: numpy, 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.colors import ListedColormap
from matplotlib.lines import Line2D
from matplotlib.ticker import NullFormatter
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor, export_text

# --- 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

# %% 1. Zemin sınıfı ağacı: Vs30, N60 ve cu
rng = np.random.default_rng(42)
n = 600
vs30 = np.exp(rng.uniform(np.log(100), np.log(2000), n))                   # m/s, log-düzgün
# Uydurma bağıntılar, tablodaki sınırları birbirine bağlar:
# Vs30 = 180 ↔ N60 = 15 ↔ cu = 70 kPa ve Vs30 = 360 ↔ N60 = 50 ↔ cu = 250 kPa
n60 = np.minimum(15 * (vs30 / 180) ** 1.737 * rng.lognormal(0, 0.25, n), 100)   # 100 = refü
cu = np.minimum(70 * (vs30 / 180) ** 1.837 * rng.lognormal(0, 0.25, n), 600)    # kPa, üst sınır
sinif = np.select([vs30 > 1500, vs30 > 760, vs30 > 360, vs30 > 180], ["ZA", "ZB", "ZC", "ZD"], "ZE")
X1 = np.column_stack([vs30, n60, cu])
X1_eg, X1_te, s1_eg, s1_te = train_test_split(X1, sinif, test_size=0.3, random_state=42, stratify=sinif)
agac1 = DecisionTreeClassifier(max_depth=4, random_state=42).fit(X1_eg, s1_eg)
esikler1 = np.sort(agac1.tree_.threshold[agac1.tree_.feature == 0])
print("=== 1. Zemin sınıfı ağacı (600 profil: " + ", ".join(f"{s} {np.sum(sinif == s)}" for s in
                                                       ["ZA", "ZB", "ZC", "ZD", "ZE"]) + ") ===")
print(f"Ağaç (derinlik ≤ 4): {agac1.get_n_leaves()} yaprak, eğitim {agac1.score(X1_eg, s1_eg):.3f}, "
      f"test {agac1.score(X1_te, s1_te):.3f}")
print(export_text(agac1, feature_names=["Vs30", "N60", "cu"], decimals=1).rstrip())
print("Öğrenilen Vs30 eşikleri: " + " / ".join(f"{e:.1f}" for e in esikler1)
      + " m/s (tablo: 180 / 360 / 760 / 1500)")
print("Özellik önemleri: " + ", ".join(f"{a} {v:.3f}" for a, v in zip(["Vs30", "N60", "cu"],
                                                                     agac1.feature_importances_)))

# %% 2. Vs30 ölçülmemişse: yalnız N60 ve cu ile zemin sınıfları (ZC, ZD, ZE)
zemin = vs30 < 760                                         # kaya sınıflarında SPT ve cu anlamlı değil
gurultu = rng.uniform(0, 1, n)                             # sınıfla hiç ilgisi olmayan bir sütun
X2 = np.column_stack([n60, cu, gurultu])[zemin]
s2 = sinif[zemin]
X2_eg, X2_te, s2_eg, s2_te = train_test_split(X2, s2, test_size=0.3, random_state=42, stratify=s2)
tam = DecisionTreeClassifier(random_state=42).fit(X2_eg, s2_eg)
yol = tam.cost_complexity_pruning_path(X2_eg, s2_eg)
alfalar = yol.ccp_alphas[:-1]                              # sonuncusu yalnız kökten oluşan ağaç
kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
cv_alfa = np.array([cross_val_score(DecisionTreeClassifier(random_state=42, ccp_alpha=a), X2_eg, s2_eg,
                                    cv=kfold).mean() for a in alfalar])
eg_alfa = np.array([DecisionTreeClassifier(random_state=42, ccp_alpha=a).fit(X2_eg, s2_eg).score(X2_eg, s2_eg)
                    for a in alfalar])
alfa_iyi = alfalar[np.isclose(cv_alfa, cv_alfa.max())].max()   # eşitlikte daha sade ağaç
budanmis = DecisionTreeClassifier(random_state=42, ccp_alpha=alfa_iyi).fit(X2_eg, s2_eg)
ad2 = ["N60", "cu", "gürültü"]
print(f"\n=== 2. Vs30 yoksa: N60, cu ve bir gürültü sütunu ({zemin.sum()} zemin profili, ZC–ZE) ===")
print(f"Budamasız  : {tam.get_n_leaves()} yaprak, derinlik {tam.get_depth()}, "
      f"eğitim {tam.score(X2_eg, s2_eg):.3f}, test {tam.score(X2_te, s2_te):.3f}")
print(f"Budanmış   : ccp_alpha = {alfa_iyi:.4f} (5 katlı CV {cv_alfa.max():.3f}), "
      f"{budanmis.get_n_leaves()} yaprak, eğitim {budanmis.score(X2_eg, s2_eg):.3f}, "
      f"test {budanmis.score(X2_te, s2_te):.3f}")
onem = zip(ad2, tam.feature_importances_, budanmis.feature_importances_)
print("Önem (budamasız → budanmış): " + ", ".join(f"{a} {v1:.3f} → {v2:.3f}" for a, v1, v2 in onem))
for j, (a, tablo) in enumerate([("N60", "15 / 50 darbe"), ("cu", "70 / 250 kPa")]):
    e_j = np.sort(budanmis.tree_.threshold[budanmis.tree_.feature == j])
    print(f"Budanmış ağaçta {a} eşikleri: " + ", ".join(f"{e:.1f}" for e in e_j) + f" (tablo: {tablo})")
olcek = StandardScaler().fit(X2_eg)
olcekli = DecisionTreeClassifier(random_state=42, ccp_alpha=alfa_iyi).fit(olcek.transform(X2_eg), s2_eg)
ayni = np.sum(olcekli.predict(olcek.transform(X2_te)) == budanmis.predict(X2_te))
print(f"Standartlaştırılmış özelliklerle aynı tahmin: {ayni}/{len(s2_te)} (ölçek ağacı etkilemez)")
kokler, tahminler = [], []
for b in range(5):                                         # aynı veriden 5 bootstrap örneklemi
    i = rng.integers(0, len(s2_eg), len(s2_eg))
    ag = DecisionTreeClassifier(random_state=42).fit(X2_eg[i], s2_eg[i])
    kokler.append(f"{ad2[ag.tree_.feature[0]]} ≤ {ag.tree_.threshold[0]:.1f}")
    tahminler.append(ag.predict(X2_te))
tahminler = np.array(tahminler)
degisen = np.mean([len(set(tahminler[:, j])) > 1 for j in range(tahminler.shape[1])])
print("5 bootstrap ağacının kök bölünmesi: " + "; ".join(kokler))
print(f"Tahmini en az bir ağaçta farklı çıkan test profili: %{100 * degisen:.0f}")


# %% 3. Sıfırdan regresyon ağacı: katmanlı zeminde Vs–derinlik profili
def vs_gercek(z):
    """Dört katmanlı sentetik profil (m/s); sınırlar 4, 11 ve 19 m, katman içinde hafif artış."""
    return np.select([z < 4, z < 11, z < 19], [150 + 5 * z, 240 + 4 * (z - 4), 340 + 3 * (z - 11)],
                     520 + 2 * (z - 19))


z = np.arange(0.5, 30.01, 0.5)                             # ölçüm derinlikleri (m)
v = vs_gercek(z) + rng.normal(0, 20, z.size)               # ölçülen Vs, gürültü σ = 20 m/s


def agac_kur(x, y, derinlik, en_cok):
    """Kare hatalar toplamını (SSE) en çok azaltan eşikle böler; derinlik sınırına ya da saf düğüme
    ulaşana kadar özyinelemeli devam eder."""
    if derinlik == en_cok or len(y) < 2 or np.all(y == y[0]):
        return {"deger": y.mean()}
    sira = np.argsort(x, kind="stable")
    xs, ys = x[sira], y[sira]
    S, Q, m = np.cumsum(ys), np.cumsum(ys ** 2), len(ys)
    nl = np.arange(1, m)                                   # soldaki örnek sayısı
    sse = (Q[:-1] - S[:-1] ** 2 / nl) + ((Q[-1] - Q[:-1]) - (S[-1] - S[:-1]) ** 2 / (m - nl))
    sse[xs[1:] <= xs[:-1]] = np.inf                        # eşit x değerlerinin arası bölünemez
    if not np.isfinite(sse).any():                         # bütün x'ler aynı: bölünecek yer yok
        return {"deger": y.mean()}
    i = int(np.argmin(sse))
    esik = (xs[i] + xs[i + 1]) / 2                         # iki komşu değerin ortası
    sol = x <= esik
    return {"esik": esik, "sol": agac_kur(x[sol], y[sol], derinlik + 1, en_cok),
            "sag": agac_kur(x[~sol], y[~sol], derinlik + 1, en_cok)}


def agac_tahmin(dugum, x):
    if "deger" in dugum:
        return np.full(x.shape, dugum["deger"])
    sol = x <= dugum["esik"]
    sonuc = np.empty(x.shape)
    sonuc[sol] = agac_tahmin(dugum["sol"], x[sol])
    sonuc[~sol] = agac_tahmin(dugum["sag"], x[~sol])
    return sonuc


def esikler(dugum):
    return [] if "deger" in dugum else [dugum["esik"]] + esikler(dugum["sol"]) + esikler(dugum["sag"])


zz = np.linspace(0, 30, 3001)                              # karşılaştırma ve çizim ızgarası
zf = np.linspace(0, 30, 300_001)
vs30_gercek = 30 / np.trapezoid(1 / vs_gercek(zf), zf)     # (Vs)30 = 30 / Σ(hᵢ/Vᵢ)
print(f"\n=== 3. Sıfırdan regresyon ağacı (Vs–derinlik, 60 ölçüm; gerçek Vs30 = {vs30_gercek:.1f} m/s) ===")
print("derinlik  yaprak  RMSE ölçüm  RMSE gerçek  sklearn farkı   Vs30 (m/s)")
agaclar = {}
for D in (1, 2, 3, 8):
    a = agac_kur(z, v, 0, D)
    agaclar[D] = a
    skl = DecisionTreeRegressor(max_depth=D).fit(z.reshape(-1, 1), v)
    fark = np.abs(agac_tahmin(a, zz) - skl.predict(zz.reshape(-1, 1))).max()
    rmse_olcum = np.sqrt(np.mean((agac_tahmin(a, z) - v) ** 2))
    rmse_gercek = np.sqrt(np.mean((agac_tahmin(a, zz) - vs_gercek(zz)) ** 2))
    vs30_agac = 30 / np.trapezoid(1 / agac_tahmin(a, zf), zf)
    print(f"{D:5d}   {len(esikler(a)) + 1:6d}   {rmse_olcum:8.1f}   {rmse_gercek:9.1f}      {fark:.1e}   "
          f"{vs30_agac:8.1f}")
    assert fark < 1e-9
print("Derinlik 3 eşikleri: " + ", ".join(f"{e:.2f}" for e in sorted(esikler(agaclar[3])))
      + f" m (kök {agaclar[3]['esik']:.2f}; gerçek: 4, 11, 19 m)")

# %% 4. Dış değer: kiriş sehiminde ağaç, eğitim aralığının dışında sabit kalır
q, E, I = 10.0, 210_000.0, 8356e4                          # N/mm, MPa, mm⁴ (IPE 300, güçlü eksen)


def sehim(L):
    """Basit mesnetli, düzgün yayılı yüklü kirişte orta açıklık sehimi (mm); L metre."""
    return 5 * q * (L * 1000) ** 4 / (384 * E * I)


L_eg = rng.uniform(2, 6, 200)
d_eg = sehim(L_eg)
agac_L = DecisionTreeRegressor(max_depth=6, random_state=42).fit(L_eg.reshape(-1, 1), d_eg)
dogru_L4 = LinearRegression().fit((L_eg ** 4).reshape(-1, 1), d_eg)    # fiziği bilen özellik: L⁴
print("\n=== 4. Dış değer: kiriş sehimi (eğitim açıklığı 2–6 m, ağaç derinliği 6) ===")
print(" L (m)   analitik (mm)   ağaç (mm)   L⁴ ile doğrusal (mm)")
for L in (4.0, 6.0, 7.5, 9.0):
    d_agac, d_L4 = agac_L.predict([[L]])[0], dogru_L4.predict([[L ** 4]])[0]
    print(f"{L:5.1f}    {sehim(L):10.2f}    {d_agac:9.2f}    {d_L4:10.2f}")
print(f"Ağacın 6 m'nin ötesindeki tahmini sabit: {agac_L.predict([[6.5]])[0]:.2f} mm "
      f"(9 m'de hata %{100 * (agac_L.predict([[9.0]])[0] / sehim(9.0) - 1):.0f})")

# %% 5. Grafikler
# Şekil 1: regresyon ağacının derinliği ve Vs–derinlik profili
fig, ax = plt.subplots(2, 2, figsize=(10, 7.5), layout="constrained", sharex=True, sharey=True)
for a, D in zip(ax.ravel(), (1, 2, 3, 8)):
    a.scatter(v, z, s=14, color=SOLUK, label="Ölçüm (sentetik)")
    a.plot(vs_gercek(zz), zz, color=MUREKKEP, ls="--", lw=1.4, label="Gerçek profil")
    a.plot(agac_tahmin(agaclar[D], zz), zz, color=RENK[0], label="Regresyon ağacı")
    a.set_title(f"Derinlik {D}: {len(esikler(agaclar[D])) + 1} yaprak")
ax[0, 0].invert_yaxis()
for a in ax[1]:
    a.set_xlabel("Kayma dalgası hızı Vs (m/s)")
for a in ax[:, 0]:
    a.set_ylabel("Derinlik z (m)")
ax[0, 0].legend(loc="lower left", fontsize=9)
fig.savefig(KLASOR / "d07_karar_agaclari_1.png", dpi=160)
plt.close(fig)

# Şekil 2: budanmış ağacın bölgeleri (N60–cu) ve budama yolu
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
siniflar = ["ZC", "ZD", "ZE"]
NN, CC = np.meshgrid(np.geomspace(3, 100, 250), np.geomspace(15, 600, 250))
bolge = budanmis.predict(np.column_stack([NN.ravel(), CC.ravel(), np.full(NN.size, 0.5)]))
kod = np.searchsorted(siniflar, bolge).reshape(NN.shape)
ax[0].contourf(NN, CC, kod, levels=[-0.5, 0.5, 1.5, 2.5], cmap=ListedColormap(RENK[:3]), alpha=0.15)
isaret = {"ZC": "s", "ZD": "o", "ZE": "^"}
for k, s in enumerate(siniflar):
    m = s2_eg == s
    ax[0].scatter(X2_eg[m, 0], X2_eg[m, 1], s=14, marker=isaret[s], facecolors="none", edgecolors=RENK[k],
                  lw=0.9, label=f"{s} (eğitim)")
for e in (15, 50):
    ax[0].axvline(e, color=MUREKKEP, ls="--", lw=1.1)
for e in (70, 250):
    ax[0].axhline(e, color=MUREKKEP, ls="--", lw=1.1)
ax[0].set(xscale="log", yscale="log", xlim=(3, 100), ylim=(15, 600), xlabel="N60 (darbe/30 cm)",
          ylabel="cu (kPa)", title=f"Budanmış ağaç ({budanmis.get_n_leaves()} yaprak), tablo sınırları")
ax[0].set_xticks([3, 5, 10, 20, 50, 100], labels=["3", "5", "10", "20", "50", "100"])
ax[0].set_yticks([20, 50, 100, 200, 500], labels=["20", "50", "100", "200", "500"])
ax[0].xaxis.set_minor_formatter(NullFormatter())
ax[0].yaxis.set_minor_formatter(NullFormatter())
tut = ax[0].get_legend_handles_labels()[0] + [Line2D([], [], color=MUREKKEP, ls="--", lw=1.1)]
ax[0].legend(handles=tut, labels=[f"{s} (eğitim)" for s in siniflar] + ["Tablodaki sınırlar"],
             loc="upper left", fontsize=8, frameon=True, framealpha=0.9, edgecolor="white")
ax[1].semilogx(alfalar[1:], eg_alfa[1:], "-o", ms=3, color=RENK[0], drawstyle="steps-post",
               label="Eğitim doğruluğu")
ax[1].semilogx(alfalar[1:], cv_alfa[1:], "-o", ms=3, color=RENK[1], drawstyle="steps-post",
               label="5 katlı CV doğruluğu")
ax[1].axvline(alfa_iyi, color=MUREKKEP, ls="--", lw=1.2, label=f"Seçilen ccp_alpha = {alfa_iyi:.4f}")
ax[1].set(xlabel="ccp_alpha (log ölçek)", ylabel="Doğruluk", title="Maliyet–karmaşıklık budaması")
ax[1].legend(loc=(0.30, 0.06), fontsize=8)
fig.savefig(KLASOR / "d07_karar_agaclari_2.png", dpi=160)
plt.close(fig)

# Şekil 3: dış değer sorunu
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
LL = np.linspace(1.5, 9.5, 400)
for a in ax:
    a.axvspan(2, 6, color=SOLUK, alpha=0.12, lw=0)
ax[0].scatter(L_eg, d_eg, s=10, color=SOLUK, label="Eğitim verisi (2–6 m)")
ax[0].plot(LL, sehim(LL), color=MUREKKEP, ls="--", lw=1.4, label="Analitik: 5qL⁴/(384EI)")
ax[0].plot(LL, agac_L.predict(LL.reshape(-1, 1)), color=RENK[0], label="Regresyon ağacı (derinlik 6)")
ax[0].plot(LL, dogru_L4.predict((LL ** 4).reshape(-1, 1)), color=RENK[1], ls=":",
           label="L⁴ ile doğrusal model")
ax[0].set(xlabel="Açıklık L (m)", ylabel="Orta açıklık sehimi δ (mm)",
          title="Eğitim aralığının dışında ağaç düzleşir")
ax[0].legend(loc="upper left", fontsize=8)
hata = 100 * (agac_L.predict(LL.reshape(-1, 1)) / sehim(LL) - 1)
ax[1].plot(LL, hata, color=RENK[0], label="Regresyon ağacı")
ax[1].axhline(0, color=MUREKKEP, lw=1)
ax[1].set(xlabel="Açıklık L (m)", ylabel="Bağıl hata (%)", ylim=(-100, 40),
          title="Ağacın bağıl hatası")
ax[1].legend(loc="lower left", fontsize=8)
fig.savefig(KLASOR / "d07_karar_agaclari_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d07_karar_agaclari_1.png, _2.png, _3.png")
