"""Ders 08 — Topluluk yöntemleri: Random Forest ve Gradient Boosting.

Sentetik beton karışımı verisinden 800 numunenin basınç dayanımını tahmin ediyoruz:
  * torbalama ve rastgele ormanın varyansı nasıl düşürdüğünü, aynı üreticiden çekilen
    16 farklı eğitim kümesiyle ölçüyoruz (Var = ρσ² + (1−ρ)σ²/B formülünün sınaması),
  * gradyan artırmayı (gradient boosting) sıfırdan yazıp scikit-learn ile karşılaştırıyoruz,
  * HistGradientBoosting ve XGBoost'u doğrulama kümesiyle erken durduruyoruz,
  * beş katlı çapraz doğrulamayla doğrusal modellerle kıyaslıyoruz,
  * modeli permütasyon önemi ve kısmi bağımlılıkla yorumluyoruz.

Veri sentetiktir (Ders 04'teki beton_verisi üreticisi): dayanım Abrams yasası ve EN 1992-1-1'deki
yaş katsayısı β_cc(t) ile, %7 log-normal gürültüyle üretilir. Gerçek deney verisi değildir.

Çalıştır:  python d08_topluluk.py
Gerekenler: numpy, pandas, scikit-learn, xgboost, matplotlib  (Python 3.12+)
Süre:      2 çekirdekli bir bilgisayarda yaklaşık yarım dakika
Çıktılar:  terminale sayılar, aynı klasöre dört PNG grafiği
"""
import os
os.environ.setdefault("OMP_NUM_THREADS", "1")  # küçük veride tek iş parçacığı: hızlı ve tekrarlanabilir

from collections import Counter
from pathlib import Path

import numpy as np
import pandas as pd
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from matplotlib.patches import Patch
from matplotlib.ticker import NullFormatter
from sklearn.ensemble import (GradientBoostingRegressor, HistGradientBoostingRegressor,
                              RandomForestRegressor)
from sklearn.inspection import permutation_importance
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score
from sklearn.model_selection import KFold
from sklearn.tree import DecisionTreeRegressor
from xgboost import XGBRegressor

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


# --- Ortak beton verisi üreticisi (kurs genelinde aynı; Ders 04 ile aynı fonksiyon) ---
def beton_verisi(n, rng, eksik_oran=0.0):
    """Sentetik beton karışımı verisi (eğitim amaçlı; gerçek deney verisi değildir).

    Dayanım, Abrams yasası (f = 96,5 / 7^(s/b) MPa) ve EN 1992-1-1'deki yaş katsayısı
    β_cc(t) = exp(s·(1 − √(28/t))) ile üretilir; s/b oranında cüruf ve uçucu kül, EN 206'daki
    k-değeri kavramına benzer biçimde 0,6 ve 0,4 etkinlikle bağlayıcıya katılır.
    """
    cimento = rng.uniform(250, 500, n)                                   # kg/m³
    curuf = np.where(rng.random(n) < 0.4, rng.uniform(20, 200, n), 0.0)  # kg/m³
    ucucu_kul = np.where(rng.random(n) < 0.3, rng.uniform(20, 150, n), 0.0)
    su = rng.uniform(150, 210, n)                                        # kg/m³
    super_akiskan = np.where(rng.random(n) < 0.6, rng.uniform(2, 12, n), 0.0)
    iri_agrega = rng.uniform(850, 1100, n)
    ince_agrega = rng.uniform(650, 900, n)
    yas_gun = rng.choice([3, 7, 14, 28, 56, 90], n, p=[.12, .2, .13, .3, .13, .12])
    tipler = np.array(["CEM I 42,5 R", "CEM II/A-LL 42,5 N", "CEM III/A 32,5 N"])
    tip_no = rng.choice(3, n, p=[.45, .35, .20])
    s_katsayi = np.array([0.20, 0.25, 0.38])[tip_no]      # EN 1992-1-1, Bağıntı 3.2: R, N, S sınıfı
    sinif_carpani = np.array([1.00, 0.97, 0.88])[tip_no]  # varsayım: dayanım sınıfı etkisi
    kalip_no = rng.integers(1, 21, n)                    # ilgisiz özellik
    ortam_sicakligi = rng.uniform(5, 30, n)              # ilgisiz özellik (bu üreticide)

    sb = su / (cimento + 0.6 * curuf + 0.4 * ucucu_kul)  # su / etkin bağlayıcı
    f28 = 96.5 / 7.0 ** sb * sinif_carpani + 0.25 * super_akiskan
    beta = np.exp(s_katsayi * (1 - np.sqrt(28 / yas_gun)))
    dayanim = f28 * beta * rng.lognormal(0.0, 0.07, n)

    df = pd.DataFrame({
        "cimento": cimento, "curuf": curuf, "ucucu_kul": ucucu_kul, "su": su,
        "super_akiskan": super_akiskan, "iri_agrega": iri_agrega, "ince_agrega": ince_agrega,
        "yas_gun": yas_gun, "cimento_tipi": tipler[tip_no], "kalip_no": kalip_no,
        "ortam_sicakligi": ortam_sicakligi, "dayanim_mpa": dayanim,
    })
    if eksik_oran > 0:
        df.loc[rng.random(n) < eksik_oran, "super_akiskan"] = np.nan
    return df


# Üreticideki sabitler: gürültüsüz "gerçek" fonksiyonu yazmak için (yalnız denetim ve grafikte)
TIPLER = ["CEM I 42,5 R", "CEM II/A-LL 42,5 N", "CEM III/A 32,5 N"]
KISA = {"CEM I 42,5 R": "CEM I", "CEM II/A-LL 42,5 N": "CEM II/A-LL", "CEM III/A 32,5 N": "CEM III/A"}
S_KATSAYI = dict(zip(TIPLER, [0.20, 0.25, 0.38]))
SINIF = dict(zip(TIPLER, [1.00, 0.97, 0.88]))
SIGMA_LN = 0.07                       # log-normal gürültünün parametresi
ILGISIZ = ["iri_agrega", "ince_agrega", "kalip_no", "ortam_sicakligi"]   # üretimde kullanılmayan


def su_baglayici(d):
    return d["su"] / (d["cimento"] + 0.6 * d["curuf"] + 0.4 * d["ucucu_kul"])


def gercek_ortalama(d, sb=None, yas=None):
    """Gürültüsüz ortalama E[dayanım | x] (MPa). sb veya yas verilirse o değere sabitlenir."""
    sb = su_baglayici(d) if sb is None else sb
    yas = d["yas_gun"] if yas is None else yas
    f28 = 96.5 / 7.0 ** sb * d["cimento_tipi"].map(SINIF) + 0.25 * d["super_akiskan"]
    beta = np.exp(d["cimento_tipi"].map(S_KATSAYI) * (1 - np.sqrt(28 / yas)))
    return np.asarray(f28 * beta, dtype=float) * np.exp(SIGMA_LN**2 / 2)  # log-normalin ortalaması


def ozellikler(d, sb=None, yas=None, sb_sutunu=False):
    """Ham sütunlar (çimento tipi üç ikili sütun); istenirse s/b sütunu eklenir."""
    X = d.drop(columns=["dayanim_mpa", "cimento_tipi"]).copy()
    if yas is not None:
        X["yas_gun"] = yas
    for tip in TIPLER:
        X[KISA[tip]] = (d["cimento_tipi"] == tip).astype(float)
    if sb_sutunu:
        X["s/b"] = su_baglayici(d) if sb is None else sb
    return X


def muhendislik(d, sb=None, yas=None, etkilesim=False):
    """Doğrusal model için: ham sütunlar + s/b + ln t (hedef: ln dayanım). Referans tip CEM I."""
    Z = ozellikler(d, sb=sb, yas=yas, sb_sutunu=True).drop(columns="CEM I")
    Z["ln_t"] = np.log(Z["yas_gun"])
    if etkilesim:  # çimento tipi sertleşme hızını değiştirir (β_cc'deki s katsayısı)
        Z["ln_t*CEM II"] = Z["ln_t"] * Z["CEM II/A-LL"]
        Z["ln_t*CEM III"] = Z["ln_t"] * Z["CEM III/A"]
    return Z


def rmse(a, b):
    return float(np.sqrt(np.mean((np.asarray(a) - np.asarray(b)) ** 2)))


# %% 1. Veri
rng = np.random.default_rng(42)
df = beton_verisi(800, rng)
y = df["dayanim_mpa"].to_numpy()
X = ozellikler(df)
ADLAR = list(X.columns)
m_gercek = gercek_ortalama(df)
taban = np.sqrt(np.mean(m_gercek**2 * (np.exp(SIGMA_LN**2) - 1)))   # gürültünün RMS'i = en iyi RMSE
print("=== 1. Veri ===")
print(f"Örnek: {len(df)}, özellik: {X.shape[1]} (çimento tipi 3 ikili sütun), "
      f"dayanım {y.min():.1f}–{y.max():.1f} MPa (ortalama {y.mean():.1f})")
print(f"Gürültü tabanı: gerçek fonksiyonun beklenen RMSE'si {taban:.2f} MPa")

# %% 2. Ortalama almak neden işe yarar? Aynı süreçten 16 eğitim kümesi
n = len(df)
print("\n=== 2. Torbalama ve rastgele orman: varyans ayrışımı ===")
tekil = np.mean([np.unique(rng.integers(0, n, n)).size / n for _ in range(200)])
print(f"Bootstrap örneğinde farklı gözlem oranı: {tekil:.3f} "
      f"(1 − (1 − 1/n)^n = {1 - (1 - 1/n)**n:.3f})")

d_sabit = beton_verisi(400, np.random.default_rng(7))       # x noktaları sabit tutulur
X_sabit = ozellikler(d_sabit).to_numpy()
m_sabit = gercek_ortalama(d_sabit)
gurultu = np.mean(m_sabit**2 * (np.exp(SIGMA_LN**2) - 1))    # indirgenemez hata (MPa²)
R, B = 16, 40
B_SINAMA = [1, 2, 5, 10, 20]       # formülü ağaçların ilk yarısıyla kurulan topluluklarda sınarız


def agac_tahminleri(max_features):
    """R eğitim kümesinin her birinde B ağaçlık orman; her ağacın sabit x'lerdeki tahmini."""
    T = np.empty((R, B, len(X_sabit)))
    for r in range(R):
        d = beton_verisi(800, np.random.default_rng(100 + r))   # aynı süreçten yeni eğitim kümesi
        orman = RandomForestRegressor(B, max_features=max_features, random_state=r, n_jobs=1)
        orman.fit(ozellikler(d).to_numpy(), d["dayanim_mpa"].to_numpy())
        T[r] = [agac.predict(X_sabit) for agac in orman.estimators_]
        if r == 0:   # ilk kümedeki ağaçlar ilk bölmeyi hangi sütunla yapıyor?
            kok = Counter(ADLAR[agac.tree_.feature[0]] for agac in orman.estimators_)
    return T, kok


def sigma_rho(U):
    """Tek ağacın varyansı σ² ve aynı kümeden iki ağacın korelasyonu ρ (x üzerinden ortalama)."""
    k = U.shape[1]
    sapma = U - U.mean(axis=(0, 1))
    sigma2 = (sapma**2).mean()
    kov = (sapma.sum(axis=1)**2 - (sapma**2).sum(axis=1)) / (k * (k - 1))   # b ≠ b' çiftleri
    return sigma2, kov.mean() / sigma2


def ayristir(T):
    """σ², ρ: ağaçların ikinci yarısından; sınama: ilk yarıdan kurulan b ağaçlı topluluklar."""
    sigma2, rho = sigma_rho(T[:, B // 2:])
    sinama = {b: (T[:, :b].mean(axis=1).var(axis=0).mean(),        # ölçülen varyans
                  rho * sigma2 + (1 - rho) * sigma2 / b)           # ρσ² + (1 − ρ)σ²/B
              for b in B_SINAMA}
    hata = {}
    for b in (1, B):
        f_b = T[:, :b].mean(axis=1)                                # b ağaçlı topluluk (R × x)
        hata[b] = (np.mean((f_b.mean(axis=0) - m_sabit)**2), f_b.var(axis=0).mean())  # yanlılık², varyans
    return sigma2, rho, sinama, hata


ayrisim, koklar = {}, {}
for ad, mf in [("Torbalama", 1.0), ("Rastgele orman", 1 / 3)]:
    T, koklar[ad] = agac_tahminleri(mf)
    sigma2, rho, sinama, hata = ayristir(T)
    ayrisim[ad] = (sigma2, rho, sinama, hata)
    print(f"{ad} (max_features={mf:.2f}): σ² = {sigma2:.2f}, ρ = {rho:.3f} | Var ölçülen/formül: "
          + ", ".join(f"B={b} {sinama[b][0]:.2f}/{sinama[b][1]:.2f}" for b in (5, 20)))
    for b in B_SINAMA:
        assert abs(sinama[b][0] / sinama[b][1] - 1) < 0.25
print("Kök bölmenin sütunu (ilk eğitim kümesi, 40 ağaç):")
print("   torbalama: " + ", ".join(f"{a} {k}" for a, k in koklar["Torbalama"].most_common())
      + " | rastgele orman: " + ", ".join(f"{a} {k}" for a, k in koklar["Rastgele orman"].most_common(4))
      + f", diğer {B - sum(k for _, k in koklar['Rastgele orman'].most_common(4))}")
print(f"Hata ayrışımı (MPa²)      yanlılık²  varyans  gürültü  toplam   RMSE")
for ad in ayrisim:
    for b in (1, B):
        y2, v = ayrisim[ad][3][b]
        etiket = f"{ad}, B={b}"
        print(f"  {etiket:22s} {y2:8.2f} {v:8.2f} {gurultu:8.2f} {y2 + v + gurultu:7.2f} "
              f"{np.sqrt(y2 + v + gurultu):6.2f}")

# Torba dışı (OOB) tahmin: her ağaç, bootstrap'a girmeyen ~%37'lik gözlemlerde sınanır
sira = rng.permutation(n)
egt, dog, tst = sira[:480], sira[480:640], sira[640:]   # eğitim / doğrulama / test
egt_dog = sira[:640]
orman = RandomForestRegressor(200, max_features=1 / 3, oob_score=True, random_state=42, n_jobs=1)
orman.fit(X.to_numpy()[egt_dog], y[egt_dog])
p_orman = orman.predict(X.to_numpy()[tst])
print(f"OOB (640 örnek): RMSE {rmse(orman.oob_prediction_, y[egt_dog]):.2f} MPa, R² {orman.oob_score_:.3f}"
      f" | ayrı test (160): RMSE {rmse(p_orman, y[tst]):.2f}, R² {r2_score(y[tst], p_orman):.3f}")


# %% 3. Gradyan artırma, sıfırdan
def gradyan_artirma(X, y, n_agac, ogrenme_hizi, derinlik=2, tohum=42):
    """Kare hata için gradyan artırma: her yeni ağaç o anki artıklara uydurulur."""
    rs = np.random.RandomState(tohum)       # scikit-learn ile aynı eşitlik bozma sırası
    f0 = y.mean()                           # F_0: en iyi sabit tahmin
    F = np.full(len(y), f0)
    agaclar = []
    for _ in range(n_agac):
        artik = y - F                       # −∂L/∂F, L = ½(y − F)²
        agac = DecisionTreeRegressor(max_depth=derinlik, random_state=rs).fit(X, artik)
        F += ogrenme_hizi * agac.predict(X)  # fonksiyon uzayında küçük bir adım
        agaclar.append(agac)
    return f0, agaclar


def asamali_tahmin(f0, agaclar, ogrenme_hizi, X):
    """1, 2, …, M ağaçlı modellerin tahminleri (M × n)."""
    katki = np.array([agac.predict(X) for agac in agaclar])
    return f0 + ogrenme_hizi * np.cumsum(katki, axis=0)


Xn = X.to_numpy()
print(f"\n=== 3. Gradyan artırma, sıfırdan (eğitim/doğrulama/test: {len(egt)}/{len(dog)}/{len(tst)}) ===")
egriler = {}
for eta, M in [(0.1, 1000), (0.3, 400), (1.0, 150)]:
    f0, agaclar = gradyan_artirma(Xn[egt], y[egt], M, eta)
    hata = {ad: np.sqrt(((asamali_tahmin(f0, agaclar, eta, Xn[i]) - y[i])**2).mean(axis=1))
            for ad, i in [("egitim", egt), ("dogrulama", dog), ("test", tst)]}
    egriler[eta] = hata
    m_en = int(hata["dogrulama"].argmin())     # erken durdurma: yalnız doğrulama hatasına bakılır
    print(f"η = {eta:3.1f}: en iyi M = {m_en + 1:3d} (doğrulama {hata['dogrulama'][m_en]:.2f}, "
          f"eğitim {hata['egitim'][m_en]:.2f}, test {hata['test'][m_en]:.2f}); "
          f"M = {M}: doğrulama {hata['dogrulama'][-1]:.2f}, eğitim {hata['egitim'][-1]:.2f}")
    if eta == 0.1:
        skl = GradientBoostingRegressor(n_estimators=200, learning_rate=0.1, max_depth=2, random_state=42)
        skl.fit(Xn[egt], y[egt])
        fark = np.abs(skl.predict(Xn[tst]) - asamali_tahmin(f0, agaclar[:200], eta, Xn[tst])[-1]).max()
        print(f"   scikit-learn GradientBoostingRegressor ile en büyük fark (200 ağaç): {fark:.1e} MPa")
        assert fark < 1e-8

# %% 4. Kütüphaneler: erken durdurma yalnız doğrulama kümesiyle
print("\n=== 4. HistGradientBoosting ve XGBoost (erken durdurma: doğrulama kümesi) ===")


def hgb_model():
    return HistGradientBoostingRegressor(learning_rate=0.05, max_iter=2000, max_leaf_nodes=15,
                                         min_samples_leaf=10, l2_regularization=1.0, early_stopping=True,
                                         n_iter_no_change=50, random_state=42)


def xgb_model():
    return XGBRegressor(n_estimators=2000, learning_rate=0.05, max_depth=3, subsample=0.8,
                        colsample_bytree=0.8, min_child_weight=1, reg_lambda=1.0,
                        early_stopping_rounds=50, eval_metric="rmse", random_state=42, n_jobs=1)


hgb = hgb_model().fit(Xn[egt], y[egt], X_val=Xn[dog], y_val=y[dog])
xgb = xgb_model().fit(Xn[egt], y[egt], eval_set=[(Xn[dog], y[dog])], verbose=False)
assert np.allclose(xgb.predict(Xn[tst]), xgb.predict(Xn[tst], iteration_range=(0, xgb.best_iteration + 1)))
print(f"HistGradientBoosting: {hgb.n_iter_} iterasyon | doğrulama {rmse(hgb.predict(Xn[dog]), y[dog]):.2f}, "
      f"test {rmse(hgb.predict(Xn[tst]), y[tst]):.2f} MPa")
print(f"XGBoost             : {xgb.best_iteration + 1} ağaç     | doğrulama "
      f"{rmse(xgb.predict(Xn[dog]), y[dog]):.2f}, test {rmse(xgb.predict(Xn[tst]), y[tst]):.2f} MPa")


# %% 5. Beş katlı çapraz doğrulama
def ic_bolme(k, oran=0.15):
    """Eğitim katının içinden erken durdurma için doğrulama parçası ayırır."""
    p = np.random.default_rng(0).permutation(k)
    j = int(round(oran * k))
    return p[j:], p[:j]


def dogrusal_ham(d_tr, d_te):
    model = LinearRegression().fit(ozellikler(d_tr).drop(columns="CEM I"), d_tr["dayanim_mpa"])
    return model.predict(ozellikler(d_te).drop(columns="CEM I"))


def dogrusal_muh(etkilesim):
    def tahmin(d_tr, d_te):
        model = LinearRegression().fit(muhendislik(d_tr, etkilesim=etkilesim), np.log(d_tr["dayanim_mpa"]))
        return np.exp(model.predict(muhendislik(d_te, etkilesim=etkilesim)))   # ln ölçeğinden geri
    return tahmin


def orman_model(mf):
    def tahmin(d_tr, d_te):
        model = RandomForestRegressor(100, max_features=mf, random_state=42, n_jobs=1)
        model.fit(ozellikler(d_tr).to_numpy(), d_tr["dayanim_mpa"])
        return model.predict(ozellikler(d_te).to_numpy())
    return tahmin


def artirma(kutuphane):
    def tahmin(d_tr, d_te):
        Xa, ya = ozellikler(d_tr).to_numpy(), d_tr["dayanim_mpa"].to_numpy()
        i_tr, i_val = ic_bolme(len(ya))
        if kutuphane == "hgb":
            model = hgb_model().fit(Xa[i_tr], ya[i_tr], X_val=Xa[i_val], y_val=ya[i_val])
        else:
            model = xgb_model().fit(Xa[i_tr], ya[i_tr], eval_set=[(Xa[i_val], ya[i_val])], verbose=False)
        return model.predict(ozellikler(d_te).to_numpy())
    return tahmin


MODELLER = {
    "Doğrusal, ham 13 sütun": dogrusal_ham,
    "Doğrusal, + s/b, ln t (ln hedef)": dogrusal_muh(False),
    "Doğrusal, + tip × ln t": dogrusal_muh(True),
    "Torbalama (100 ağaç)": orman_model(1.0),
    "Rastgele orman (100, p/3)": orman_model(1 / 3),
    "HistGradientBoosting": artirma("hgb"),
    "XGBoost": artirma("xgb"),
}
skor = {ad: [] for ad in MODELLER}
for i_tr, i_te in KFold(5, shuffle=True, random_state=42).split(df):
    d_tr, d_te = df.iloc[i_tr], df.iloc[i_te]
    for ad, tahmin in MODELLER.items():
        p = tahmin(d_tr, d_te)
        y_te = d_te["dayanim_mpa"].to_numpy()
        skor[ad].append([mean_absolute_error(y_te, p), rmse(p, y_te), r2_score(y_te, p)])
print("\n=== 5. Beş katlı çapraz doğrulama (ortalama ± std, MPa) ===")
print(f"{'Model':34s} {'MAE':>13s} {'RMSE':>13s} {'R²':>15s}")
for ad, s in skor.items():
    s = np.array(s)
    ort, std = s.mean(axis=0), s.std(axis=0, ddof=1)
    print(f"{ad:34s} {ort[0]:5.2f} ± {std[0]:4.2f}  {ort[1]:5.2f} ± {std[1]:4.2f}  "
          f"{ort[2]:6.3f} ± {std[2]:5.3f}")
    assert np.all(np.isfinite(s))
print(f"{'Gürültü tabanı (gerçek fonksiyon)':34s} {'':13s}  {taban:5.2f}")
fark = np.array(skor["XGBoost"])[:, 1] - np.array(skor["Doğrusal, + tip × ln t"])[:, 1]
print("Katlara göre RMSE farkı, XGBoost − doğrusal(+tip × ln t): "
      + " ".join(f"{f:+.2f}" for f in fark))

# %% 6. Yorumlama: safsızlık önemi ve permütasyon önemi (test kümesinde)
print("\n=== 6. Yorumlama ===")
perm = permutation_importance(orman, Xn[tst], y[tst], n_repeats=5, random_state=42,
                              scoring="neg_root_mean_squared_error")
mdi = orman.feature_importances_
sira_onem = np.argsort(-perm.importances_mean)
kullanilan = [j for j in sira_onem if ADLAR[j] not in ILGISIZ]   # üretimde kullanılan 9 sütun
print("Rastgele orman: permütasyon önemi (test RMSE artışı, MPa) / safsızlık önemi (MDI)")
print("  En önemli 5: "
      + ", ".join(f"{ADLAR[j]} {perm.importances_mean[j]:.2f}/{mdi[j]:.3f}" for j in kullanilan[:5]))
print("  Kullanılan diğer 4: "
      + ", ".join(f"{ADLAR[j]} {perm.importances_mean[j]:.2f}/{mdi[j]:.3f}" for j in kullanilan[5:]))
print("  İlgisiz: " + ", ".join(f"{a} {perm.importances_mean[ADLAR.index(a)]:.2f}/{mdi[ADLAR.index(a)]:.3f}"
                                 for a in ILGISIZ))
for a in ILGISIZ:   # permütasyon önemi ilgisiz sütunlarda sıfıra yakın olmalı
    assert abs(perm.importances_mean[ADLAR.index(a)]) < 0.15

# s/b sütunu eklenmiş XGBoost ve kısmi bağımlılık (PD)
Xs = ozellikler(df, sb_sutunu=True).to_numpy()
xgb_sb = xgb_model().fit(Xs[egt], y[egt], eval_set=[(Xs[dog], y[dog])], verbose=False)
ADLAR_SB = ADLAR + ["s/b"]
perm_sb = permutation_importance(xgb_sb, Xs[tst], y[tst], n_repeats=10, random_state=42,
                                 scoring="neg_root_mean_squared_error").importances_mean
print(f"XGBoost + s/b ({xgb_sb.best_iteration + 1} ağaç, test RMSE "
      f"{rmse(xgb_sb.predict(Xs[tst]), y[tst]):.2f}): permütasyon s/b "
      f"{perm_sb[ADLAR_SB.index('s/b')]:.2f}, su {perm_sb[ADLAR_SB.index('su')]:.2f}, "
      f"çimento {perm_sb[ADLAR_SB.index('cimento')]:.2f}, yaş {perm_sb[ADLAR_SB.index('yas_gun')]:.2f}")
d_pd = df.iloc[egt_dog]                       # PD, eğitim verisinin dağılımı üzerinden ortalanır
lin = LinearRegression().fit(muhendislik(d_pd, etkilesim=True), np.log(d_pd["dayanim_mpa"]))


def kismi_bagimlilik(alan, izgara):
    """Her ızgara değerinde alanı tüm satırlarda sabitle, tahminlerin ortalamasını al."""
    sonuc = {"gercek": [], "xgb": [], "dogrusal": []}
    for v in izgara:
        k = {alan: v}
        sonuc["gercek"].append(gercek_ortalama(d_pd, **k).mean())
        sonuc["xgb"].append(xgb_sb.predict(ozellikler(d_pd, sb_sutunu=True, **k).to_numpy()).mean())
        sonuc["dogrusal"].append(np.exp(lin.predict(muhendislik(d_pd, etkilesim=True, **k))).mean())
    return {a: np.array(b) for a, b in sonuc.items()}


sb_aralik = su_baglayici(d_pd).agg(["min", "max"]).to_numpy()
izgara_sb = np.linspace(0.15, 0.95, 41)
izgara_t = np.geomspace(1, 365, 41)
pd_sb = kismi_bagimlilik("sb", izgara_sb)
pd_t = kismi_bagimlilik("yas", izgara_t)
print(f"Kısmi bağımlılık (MPa)    gerçek  XGBoost  doğrusal   [eğitim: s/b "
      f"{sb_aralik[0]:.2f}–{sb_aralik[1]:.2f}, t 3–90 gün]")
NOKTALAR = [("s/b = 0.40", "sb", 0.40), ("s/b = 0.60", "sb", 0.60), ("s/b = 0.20 (dışarıda)", "sb", 0.20),
            ("t = 7 gün", "yas", 7.0), ("t = 28 gün", "yas", 28.0), ("t = 365 gün (dışarıda)", "yas", 365.0)]
for ad, alan, v in NOKTALAR:
    r_ = kismi_bagimlilik(alan, [v])
    print(f"  {ad:22s} {r_['gercek'][0]:7.2f} {r_['xgb'][0]:8.2f} {r_['dogrusal'][0]:10.2f}")
katsayi = dict(zip(muhendislik(d_pd, etkilesim=True).columns, lin.coef_))
print(f"Doğrusal modelin yaş katsayıları (ln dayanım): yas_gun {katsayi['yas_gun']:+.4f} 1/gün, "
      f"ln_t {katsayi['ln_t']:+.3f}")

# %% 7. Grafikler
# Şekil 1: ortalamanın varyansı ve hata ayrışımı
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
bb = np.geomspace(1, B, 100)
tutamac = []
for k, (ad, (sigma2, rho, sinama, _)) in enumerate(ayrisim.items()):
    ax[0].plot(bb, rho * sigma2 + (1 - rho) * sigma2 / bb, color=RENK[k])              # formül
    ax[0].plot(B_SINAMA, [sinama[b][0] for b in B_SINAMA], "o", color=RENK[k], ms=6)    # ölçülen
    ax[0].axhline(rho * sigma2, color=RENK[k], ls=":", lw=1.2)                           # B → ∞ sınırı
    tutamac.append(Line2D([], [], color=RENK[k], marker="o", ms=6, label=f"{ad} (ρ = {rho:.3f})"))
tutamac.append(Line2D([], [], color=SOLUK, ls=":", lw=1.2, label="B → ∞ sınırı: ρσ²"))
ax[0].set_xscale("log")
ax[0].set_yscale("log")
ax[0].set_xticks([1, 2, 5, 10, 20, 40], ["1", "2", "5", "10", "20", "40"])
ax[0].set_yticks([1, 2, 5, 10, 20, 50], ["1", "2", "5", "10", "20", "50"])
ax[0].xaxis.set_minor_formatter(NullFormatter())
ax[0].yaxis.set_minor_formatter(NullFormatter())
ax[0].set(xlabel="Ağaç sayısı B", ylabel="Topluluk tahmininin varyansı (MPa²)", ylim=(0.9, 60),
          title="Varyans: formül (çizgi) ve ölçüm (nokta)")
ax[0].legend(handles=tutamac, loc="upper right")
etiketler, yan, var = [], [], []
for ad in ayrisim:
    iki_satir = ad.replace(" ", "\n")
    for b in (1, B):
        etiketler.append(f"{iki_satir}\nB = {b}")
        yan.append(ayrisim[ad][3][b][0])
        var.append(ayrisim[ad][3][b][1])
xk = np.arange(4)
ax[1].bar(xk, yan, color=RENK[0], label="yanlılık²")
ax[1].bar(xk, var, bottom=yan, color=RENK[1], label="varyans")
ax[1].bar(xk, gurultu, bottom=np.add(yan, var), color=SOLUK, label="gürültü")
for x_, toplam in zip(xk, np.add(yan, var) + gurultu):
    ax[1].text(x_, toplam + 1.5, f"RMSE {np.sqrt(toplam):.2f}", ha="center", fontsize=9, color=IKINCIL)
ax[1].set_xticks(xk, etiketler, fontsize=9)
ax[1].set(ylabel="Beklenen test MSE (MPa²)", ylim=(0, 80),
          title="Hata ayrışımı: kazanç varyanstan geliyor")
ax[1].legend(loc="upper center", ncol=3)
fig.savefig(KLASOR / "d08_topluluk_1.png", dpi=160)
plt.close(fig)

# Şekil 2: artırmada eğitim/doğrulama hatası ve öğrenme hızı
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
h = egriler[0.1]
mm = np.arange(1, len(h["egitim"]) + 1)
m_en = int(h["dogrulama"].argmin())
ax[0].plot(mm, h["egitim"], color=RENK[0], label="Eğitim")
ax[0].plot(mm, h["dogrulama"], color=RENK[1], label="Doğrulama")
ax[0].axvline(m_en + 1, color=MUREKKEP, ls=":", lw=1.2, label=f"Erken durdurma: M = {m_en + 1}")
ax[0].axhline(taban, color=SOLUK, ls="--", lw=1.2, label=f"Gürültü tabanı ({taban:.2f} MPa)")
ax[0].set(xlabel="Ağaç sayısı M", ylabel="RMSE (MPa)", ylim=(0, 16),
          title="Sıfırdan gradyan artırma (η = 0.1, derinlik 2)")
ax[0].legend(loc="upper left")
for k, eta in enumerate([1.0, 0.3, 0.1]):
    d_ = egriler[eta]["dogrulama"]
    j = int(d_.argmin())
    renk = RENK[[2, 1, 0][k]]
    ax[1].plot(np.arange(1, len(d_) + 1), d_, color=renk, label=f"η = {eta:g} (en iyi M = {j + 1})")
    ax[1].plot(j + 1, d_[j], "o", color=renk, ms=6)
ax[1].set(xlabel="Ağaç sayısı M", ylabel="Doğrulama RMSE (MPa)", ylim=(3, 8),
          title="Öğrenme hızı küçüldükçe gereken ağaç artar")
ax[1].legend(loc="upper right")
for a in ax:
    a.set_xscale("log")
    a.set_xticks([1, 10, 100, 1000], ["1", "10", "100", "1000"])
fig.savefig(KLASOR / "d08_topluluk_2.png", dpi=160)
plt.close(fig)

# Şekil 3: safsızlık önemi ve permütasyon önemi
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained", sharey=True)
sira_c = np.argsort(perm.importances_mean)
renk_c = [SOLUK if ADLAR[j] in ILGISIZ else RENK[0] for j in sira_c]
yk = np.arange(len(ADLAR))
ax[0].barh(yk, mdi[sira_c], color=renk_c)
ax[0].set_yticks(yk, [ADLAR[j] for j in sira_c])
ax[0].set(xlabel="Safsızlık önemi (MDI, toplam 1)", title="Eğitimde safsızlık azalması (MDI)")
ax[1].barh(yk, perm.importances_mean[sira_c], xerr=perm.importances_std[sira_c], color=renk_c,
           error_kw={"ecolor": MUREKKEP, "lw": 1})
ax[1].axvline(0, color=MUREKKEP, lw=1)
ax[1].set(xlabel="Permütasyon önemi: test RMSE artışı (MPa)",
          title="Test kümesinde permütasyon önemi")
ax[1].legend(handles=[Patch(color=RENK[0], label="üretimde kullanılan"),
                      Patch(color=SOLUK, label="üretimde kullanılmayan")], loc="lower right")
fig.savefig(KLASOR / "d08_topluluk_3.png", dpi=160)
plt.close(fig)

# Şekil 4: kısmi bağımlılık ve aralık dışı davranış
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for a, izgara, pdv, aralik, xl in [(ax[0], izgara_sb, pd_sb, sb_aralik, "Su/bağlayıcı oranı s/b"),
                                   (ax[1], izgara_t, pd_t, (3, 90), "Yaş t (gün, log ölçek)")]:
    a.axvspan(*aralik, color="#e1e0d9", alpha=0.6, lw=0, label="Eğitim verisinin aralığı")
    a.plot(izgara, pdv["gercek"], color=MUREKKEP, ls="--", lw=1.6, label="Gerçek (üretici)")
    a.plot(izgara, pdv["xgb"], color=RENK[0], label="XGBoost (+ s/b sütunu)")
    a.plot(izgara, pdv["dogrusal"], color=RENK[1], label="Doğrusal (+ tip × ln t)")
    a.set(xlabel=xl, ylabel="Ortalama tahmin (MPa)")
ax[0].set_title("Kısmi bağımlılık: Abrams eğrisi")
ax[1].set_xscale("log")
ax[1].set_xticks([1, 3, 7, 28, 90, 365], ["1", "3", "7", "28", "90", "365"])
ax[1].xaxis.set_minor_formatter(NullFormatter())
ax[1].set_title(r"Kısmi bağımlılık: yaş katsayısı $\beta_{cc}(t)$")
ax[0].legend(loc="upper right")
fig.savefig(KLASOR / "d08_topluluk_4.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d08_topluluk_1.png, _2.png, _3.png, _4.png")
