"""Ders 17 — Güvenilir makine öğrenmesi.

Beton basınç dayanımını tahmin eden bir modeli yorumluyoruz (permütasyon önemi, kısmi bağımlılık ve
ICE, sıfırdan kesin Shapley değerleri), fiziğe aykırı davranışı monoton kısıtlarla önlüyoruz, eğitim
verisinden uzak (dağılım dışı) girdileri işaretliyoruz, görülmemiş bir çimento tipiyle ortak değişken
kaymasını gösteriyoruz ve modeli tekrarlanabilir biçimde kaydediyoruz. Veri sentetiktir: kursun ortak
beton üreticisiyle (Abrams yasası, yaşa bağlı dayanım kazanımı ve gürültü) üretilir; gerçek deney
verisi değildir.

Çalıştır:  python d17_guvenilir_ml.py
Gerekenler: numpy, pandas, scipy, scikit-learn, matplotlib  (Python 3.12+; joblib scikit-learn ile gelir)
Çıktılar:  terminale sayılar, aynı klasöre dört PNG grafiği
"""
import hashlib
import itertools
import math
import tempfile
from pathlib import Path

import joblib
import numpy as np
import pandas as pd
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt
import sklearn
from scipy import stats
from sklearn.ensemble import HistGradientBoostingRegressor, IsolationForest
from sklearn.inspection import partial_dependence, permutation_importance
from sklearn.metrics import r2_score, root_mean_squared_error

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


# %% 0. Kursun ortak beton verisi üreticisi (Ders 04 ile aynı, birebir kopya)
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


TIPLER = ["CEM I 42,5 R", "CEM II/A-LL 42,5 N", "CEM III/A 32,5 N"]
OZ = ["su_baglayici", "yas_gun", "super_akiskan", "cimento_tipi",
      "iri_agrega", "ince_agrega", "kalip_no", "ortam_sicakligi"]          # son dördü bilerek ilgisiz


def hazirla(df):
    """Ders 04'teki anlamlı özellik: etkin su/bağlayıcı oranı. Tamsayı sütunlar PD için float olur."""
    df = df.copy()
    df["su_baglayici"] = df["su"] / (df["cimento"] + 0.6 * df["curuf"] + 0.4 * df["ucucu_kul"])
    df["cimento_tipi"] = pd.Categorical(df["cimento_tipi"], categories=TIPLER)
    df[["yas_gun", "kalip_no"]] = df[["yas_gun", "kalip_no"]].astype(float)
    return df


def hgb(**ayar):
    return HistGradientBoostingRegressor(max_iter=300, learning_rate=0.05, random_state=42, **ayar)


def rmse(y, p):
    return root_mean_squared_error(y, p)


# %% 1. Veri ve temel model
rng = np.random.default_rng(42)
veri = hazirla(beton_verisi(2000, rng))
egitim, test = veri.iloc[:1500], veri.iloc[1500:]
y_test = test["dayanim_mpa"].to_numpy()
model = hgb().fit(egitim[OZ], egitim["dayanim_mpa"])
tahmin = model.predict(test[OZ])
print("=== 1. Veri ve temel model ===")
print(f"{len(veri)} karışım ({len(egitim)} eğitim, {len(test)} test); 8 özellik, son dördü ilgisiz")
print(f"HistGradientBoosting: test RMSE = {rmse(y_test, tahmin):.2f} MPa, "
      f"R² = {r2_score(y_test, tahmin):.3f}")

# %% 2. Permütasyon önemi: bir sütunu karıştırınca test hatası ne kadar artıyor?
pi = permutation_importance(model, test[OZ], y_test, n_repeats=10, random_state=42,
                            scoring="neg_root_mean_squared_error")
sira = np.argsort(-pi.importances_mean)
print("\n=== 2. Permütasyon önemi (test kümesi, 10 tekrar; RMSE artışı, MPa) ===")
for parca in (sira[:4], sira[4:]):
    print("   " + ", ".join(f"{OZ[i]} {pi.importances_mean[i]:.2f}±{pi.importances_std[i]:.2f}"
                            for i in parca))
assert set(np.array(OZ)[sira[:3]]) == {"su_baglayici", "yas_gun", "cimento_tipi"}


# %% 3. Kısmi bağımlılık (PD) ve ICE eğrileri
def ice(m, X, ad, izgara):
    """Her satır için tek özelliği ızgarada gezdir, diğerlerini sabit tut → (satır, ızgara) tahmin matrisi."""
    Z = pd.concat([X.assign(**{ad: v}) for v in izgara], ignore_index=True)
    return m.predict(Z).reshape(len(izgara), -1).T


def ihlal(m, X, yas_izgara, sb_izgara):
    """Yaşla azalan ya da s/b ile artan adımı olan ICE eğrilerinin oranı ve en büyük ihlal (MPa)."""
    d_yas = np.diff(ice(m, X, "yas_gun", yas_izgara), axis=1)
    d_sb = np.diff(ice(m, X, "su_baglayici", sb_izgara), axis=1)
    return (d_yas < -1e-9).any(1).mean(), (d_sb > 1e-9).any(1).mean(), max(0.0, -d_yas.min(), d_sb.max())


X_ice = test[OZ].iloc[:300]
pd_sb = partial_dependence(model, X_ice, ["su_baglayici"], kind="both", grid_resolution=25)
pd_yas = partial_dependence(model, X_ice, ["yas_gun"], kind="both")
YAS = pd_yas["grid_values"][0]                                   # 3, 7, 14, 28, 56, 90
SB = np.linspace(0.30, 0.70, 21)
i_yas, i_sb, i_max = ihlal(model, X_ice, YAS, SB)
print("\n=== 3. Kısmi bağımlılık (PD) ve ICE (300 test karışımı) ===")
g = pd_sb["grid_values"][0]
print(f"PD, s/b: {g[0]:.3f} → {g[-1]:.3f} arasında "
      f"{pd_sb['average'][0, 0]:.1f} → {pd_sb['average'][0, -1]:.1f} MPa")
print("PD, yaş: " + ", ".join(f"{a:.0f} g {v:.2f}" for a, v in zip(YAS, pd_yas["average"][0])) + " MPa")
print(f"ICE: yaşla azalan adımı olan eğri %{i_yas * 100:.0f}, s/b ile artan adımı olan eğri "
      f"%{i_sb * 100:.0f}; en büyük ihlal {i_max:.2f} MPa")


# %% 4. Shapley değerleri: kesin hesap, sıfırdan (4 özellikli küçük model)
def shapley_kesin(f, x, arka_plan):
    """Girişimsel (marjinal) beklenen değerle kesin Shapley değerleri: 2^p koalisyonun hepsi."""
    p = len(x)
    v = {}                                            # koalisyon değeri v(S) = E[f(x_S, X_S̄)]
    for r in range(p + 1):
        for S in itertools.combinations(range(p), r):
            Z = arka_plan.copy()
            Z[:, list(S)] = x[list(S)]                # S'deki özellikler x'ten, diğerleri arka plandan
            v[S] = f(Z).mean()
    phi = np.zeros(p)
    for j in range(p):
        digerleri = [k for k in range(p) if k != j]
        for r in range(p):
            for S in itertools.combinations(digerleri, r):
                agirlik = math.factorial(r) * math.factorial(p - r - 1) / math.factorial(p)
                phi[j] += agirlik * (v[tuple(sorted(S + (j,)))] - v[S])
    return phi, v[()], v[tuple(range(p))]            # φ, E[f], f(x)


OZ4 = ["su_baglayici", "yas_gun", "super_akiskan", "ortam_sicakligi"]
model4 = hgb().fit(egitim[OZ4], egitim["dayanim_mpa"])
arka_plan = egitim[OZ4].to_numpy()[:200]


def f4(Z):
    return model4.predict(pd.DataFrame(Z, columns=OZ4))


print("\n=== 4. Kesin Shapley değerleri (4 özellik, 16 koalisyon, 200 satırlık arka plan) ===")
print(f"Küçük model test RMSE = {rmse(y_test, model4.predict(test[OZ4])):.2f} MPa")
ornekler = {"A": np.array([0.65, 7.0, 0.0, 25.0]), "B": np.array([0.35, 56.0, 8.0, 10.0])}
shap_sonuc = {}
for ad, x in ornekler.items():
    phi, Ef, fx = shapley_kesin(f4, x, arka_plan)
    shap_sonuc[ad] = (phi, Ef, fx)
    print(f"{ad} (s/b {x[0]:.2f}, {x[1]:.0f} g, SA {x[2]:.0f}, {x[3]:.0f} °C): "
          f"f(x) = {fx:.2f}, E[f] = {Ef:.2f} MPa")
    print("   φ (s/b, yaş, SA, sıcaklık) = " + ", ".join(f"{v:+.2f}" for v in phi)
          + f"; Σφ − (f(x) − E[f]) = {phi.sum() - (fx - Ef):.1e}")
    assert abs(phi.sum() - (fx - Ef)) < 1e-9                 # verimlilik (efficiency) özelliği

# %% 5. Fiziksel tutarlılık: monoton kısıtlar, küçük ve gürültülü eğitim kümeleri
KISIT = {"su_baglayici": -1, "yas_gun": 1}      # dayanım: s/b artınca azalır, yaş artınca artar
X_mon = test[OZ].iloc[:200]
sonuc = {"serbest": [], "kısıtlı": []}
ice_ornek = {}
for tohum in range(10):
    kucuk = hazirla(beton_verisi(100, np.random.default_rng(100 + tohum)))
    for ad, kisit in [("serbest", None), ("kısıtlı", KISIT)]:
        m = HistGradientBoostingRegressor(max_iter=200, learning_rate=0.1, min_samples_leaf=5,
                                          monotonic_cst=kisit, random_state=42)
        m.fit(kucuk[OZ], kucuk["dayanim_mpa"])
        sonuc[ad].append([rmse(y_test, m.predict(test[OZ])), *ihlal(m, X_mon, YAS, SB)])
        if tohum == 0:
            ice_ornek[ad] = ice(m, X_mon.iloc[:15], "su_baglayici", SB)
sonuc = {ad: np.array(v) for ad, v in sonuc.items()}
print("\n=== 5. Monoton kısıtlar: 10 küçük eğitim kümesi × 100 karışım (min_samples_leaf = 5) ===")
for ad, s in sonuc.items():
    print(f"{ad:8s}: test RMSE {s[:, 0].mean():.2f} MPa; ICE ihlali yaş %{s[:, 1].mean() * 100:.0f}, "
          f"s/b %{s[:, 2].mean() * 100:.0f}; en büyük ihlal {s[:, 3].max():.2f} MPa")
kazanc = int((sonuc["kısıtlı"][:, 0] < sonuc["serbest"][:, 0]).sum())
print(f"Kısıtlı modelin test RMSE'si daha düşük: 10 kümeden {kazanc}")
assert sonuc["kısıtlı"][:, 1:3].max() == 0

# %% 6. Uygulama alanı: eğitim verisinden uzak girdileri işaretlemek
havuz = hazirla(beton_verisi(4000, rng))
alan_ici = havuz["su_baglayici"].between(0.40, 0.60) & havuz["yas_gun"].isin([7, 14, 28, 56])
dar = havuz[alan_ici].iloc[:800]                 # santralin geçmişi: yalnız olağan karışımlar
dar_model = hgb().fit(dar[OZ], dar["dayanim_mpa"])
yeni = hazirla(beton_verisi(2000, rng))          # yeni sorgular: üreticinin tüm aralığı
y_yeni = yeni["dayanim_mpa"].to_numpy()
hata = dar_model.predict(yeni[OZ]) - y_yeni
buyuk = np.abs(hata) / y_yeni > 0.15             # “büyük hata”: %15'ten fazla


def uzay(df):
    """Uzaklık, modelin önemli bulduğu sayısal özelliklerde ölçülür; yaş logaritmik alınır."""
    return np.column_stack([df["su_baglayici"], np.log(df["yas_gun"]), df["super_akiskan"]])


F_e, F_y = uzay(dar), uzay(yeni)
ort, S_ters = F_e.mean(0), np.linalg.inv(np.cov(F_e, rowvar=False))


def mahalanobis(F):
    d = F - ort
    return np.sqrt(np.einsum("ij,jk,ik->i", d, S_ters, d))


d_yeni = mahalanobis(F_y)
esik = np.quantile(mahalanobis(F_e), 0.99)        # eğitim noktalarının %99'u bu uzaklığın içinde
bayrak = {
    "aralık kontrolü": ((F_y < F_e.min(0)) | (F_y > F_e.max(0))).any(1),
    "Mahalanobis": d_yeni > esik,
    "IsolationForest": IsolationForest(n_estimators=200, contamination=0.01,
                                       random_state=42).fit(F_e).predict(F_y) == -1,
}
ic = (yeni["su_baglayici"].between(0.40, 0.60) & yeni["yas_gun"].isin([7, 14, 28, 56])).to_numpy()
print("\n=== 6. Uygulama alanı ve dağılım dışı girdiler ===")
print(f"Eğitim: s/b 0.40–0.60, yaş 7–56 g ({len(dar)} karışım); yeni girdiler: tüm aralık ({len(yeni)})")
print(f"RMSE: alan içi {np.sqrt(np.mean(hata[ic]**2)):.2f} MPa ({ic.sum()}), alan dışı "
      f"{np.sqrt(np.mean(hata[~ic]**2)):.2f} MPa ({(~ic).sum()}); %15'ten büyük hata: {buyuk.sum()} girdi")
SINIRLAR = [0, 1, 2, 3, 4, 7]
kutular = [(d_yeni >= a) & (d_yeni < b) for a, b in zip(SINIRLAR[:-1], SINIRLAR[1:])]
kutu_rmse = [np.sqrt(np.mean(hata[k]**2)) for k in kutular]
kutu_n = [int(k.sum()) for k in kutular]
print("RMSE, eğitime Mahalanobis uzaklığına göre (MPa): "
      + ", ".join(f"{a}–{b} {r:.2f}" for a, b, r in zip(SINIRLAR[:-1], SINIRLAR[1:], kutu_rmse)))
for ad, b in bayrak.items():
    yakalama = (b & buyuk).sum() / buyuk.sum() * 100
    etiket = f"Mahalanobis > {esik:.2f}" if ad == "Mahalanobis" else ad
    print(f"   {etiket:18s}: işaretli %{b.mean() * 100:4.1f}, büyük hata yakalama %{yakalama:4.1f}; "
          f"RMSE işaretsiz/işaretli {np.sqrt(np.mean(hata[~b]**2)):.2f}/{np.sqrt(np.mean(hata[b]**2)):.2f}")
yas_y = yeni["yas_gun"].to_numpy()
print("Yaşa göre sapma (tahmin − ölçüm, MPa): "
      + ", ".join(f"{a:.0f} g {hata[yas_y == a].mean():+.2f}" for a in YAS))
assert d_yeni.max() < SINIRLAR[-1] and sum(kutu_n) == len(yeni)

# %% 7. Ortak değişken kayması: eğitimde hiç görülmeyen çimento tipi
eski = egitim[egitim["cimento_tipi"] != TIPLER[2]]
kayma_model = hgb().fit(eski[OZ], eski["dayanim_mpa"])
aday = hazirla(beton_verisi(1500, rng))
parti = aday[aday["cimento_tipi"] == TIPLER[2]].iloc[:300]      # yeni tedarikçi: CEM III/A
yeni_kategori = set(parti["cimento_tipi"].unique()) - set(eski["cimento_tipi"].unique())
p_ks = [stats.ks_2samp(eski[s], parti[s]).pvalue for s in ["su_baglayici", "yas_gun", "super_akiskan"]]
sapma = kayma_model.predict(parti[OZ]) - parti["dayanim_mpa"].to_numpy()
erken = parti["yas_gun"].to_numpy() <= 7
print("\n=== 7. Ortak değişken kayması: görülmemiş çimento tipi ===")
print(f"Eğitim: yalnız CEM I ve CEM II ({len(eski)} karışım); yeni parti: {len(parti)} karışım {TIPLER[2]}")
print(f"Şema kontrolü: yeni kategori {sorted(yeni_kategori)} → alarm (model ise sessizce tahmin üretir)")
print("KS testi p değerleri (s/b, yaş, SA): " + ", ".join(f"{p:.2f}" for p in p_ks))
print(f"Ölçümler gelince: ortalama sapma {sapma.mean():+.2f} MPa, RMSE {np.sqrt(np.mean(sapma**2)):.2f} MPa; "
      f"3–7 günde ortalama sapma {sapma[erken].mean():+.2f} MPa")

# %% 8. Tekrarlanabilirlik: sürümler, veri parmak izi, model kaydı
print("\n=== 8. Tekrarlanabilirlik ===")
print(f"Sürümler: numpy {np.__version__}, pandas {pd.__version__}, scikit-learn {sklearn.__version__}, "
      f"joblib {joblib.__version__}")
with tempfile.TemporaryDirectory() as klasor:
    veri_yolu = Path(klasor) / "egitim.csv"
    egitim.to_csv(veri_yolu, index=False)                       # veri sürümü: kaydedilen dosyanın parmak izi
    parmak_izi = hashlib.sha256(veri_yolu.read_bytes()).hexdigest()
    yol = Path(klasor) / "beton_modeli.joblib"
    joblib.dump(model, yol)
    yuklenen = joblib.load(yol)                    # yükleme kod çalıştırabilir: yalnız güvenilir dosya!
    ozdes = bool(np.array_equal(yuklenen.predict(test[OZ]), tahmin))
print(f"Veri parmak izi (CSV, SHA-256, ilk 16): {parmak_izi[:16]}; "
      f"kaydet–yükle sonrası tahminler özdeş: {ozdes}")
assert ozdes

# %% 9. Grafikler
ADLAR = {"su_baglayici": "s/b", "yas_gun": "yaş", "super_akiskan": "süperakışkan",
         "cimento_tipi": "çimento tipi", "iri_agrega": "iri agrega", "ince_agrega": "ince agrega",
         "kalip_no": "kalıp no", "ortam_sicakligi": "ortam sıcaklığı"}
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
s2 = sira[::-1]
ax[0].barh([ADLAR[OZ[i]] for i in s2], pi.importances_mean[s2], xerr=pi.importances_std[s2],
           color=RENK[0], height=0.6, error_kw=dict(ecolor=MUREKKEP, lw=1, capsize=2))
ax[0].axvline(0, color=MUREKKEP, lw=0.8)
ax[0].set(xlabel="Karıştırınca test RMSE artışı (MPa)", title="Permütasyon önemi (10 tekrar)")
konum = np.arange(len(OZ4))
for k, ad in enumerate(["A", "B"]):
    phi, Ef, fx = shap_sonuc[ad]
    ax[1].barh(konum + (0.2 if k == 0 else -0.2), phi, height=0.38, color=RENK[k],
               label=f"{ad}: f(x) = {fx:.1f} MPa")
ax[1].set_yticks(konum, [ADLAR[o] for o in OZ4])
ax[1].invert_yaxis()
ax[1].axvline(0, color=MUREKKEP, lw=0.8)
ax[1].set(xlabel="Shapley değeri φ (MPa)", title=f"Kesin Shapley değerleri (E[f] = {Ef:.1f} MPa)")
ax[1].legend(loc="lower left", fontsize=8.5)
fig.savefig(KLASOR / "d17_guvenilir_ml_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for k, (sonuc_pd, x_ad) in enumerate([(pd_sb, "Su/bağlayıcı oranı s/b"), (pd_yas, "Yaş (gün, log ölçek)")]):
    gx = sonuc_pd["grid_values"][0]
    for egri in sonuc_pd["individual"][0][:12]:
        ax[k].plot(gx, egri, color=SOLUK, lw=0.7)
    ax[k].plot([], [], color=SOLUK, lw=0.7, label="ICE (12 karışım)")
    ax[k].plot(gx, sonuc_pd["average"][0], color=RENK[0], lw=2.5, label="PD (300 karışım ortalaması)")
    ax[k].set(xlabel=x_ad, ylabel="Tahmini dayanım (MPa)")
    ax[k].legend(loc="upper right" if k == 0 else "upper left")
ax[1].set_xscale("log")
ax[1].set_xticks(YAS, [f"{a:.0f}" for a in YAS])
ax[1].minorticks_off()
ax[0].set_title("s/b artınca dayanım düşüyor")
ax[1].set_title("Yaşla dayanım kazanımı")
fig.savefig(KLASOR / "d17_guvenilir_ml_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained", sharey=True)
for k, ad in enumerate(["serbest", "kısıtlı"]):
    egriler = ice_ornek[ad]
    bozuk = (np.diff(egriler, axis=1) > 1e-9).any(1)
    for egri, b in zip(egriler, bozuk):
        ax[k].plot(SB, egri, color=RENK[1] if b else RENK[0], lw=0.8)
    ax[k].plot([], [], color=RENK[0], lw=1, label="monoton azalan")
    ax[k].plot([], [], color=RENK[1], lw=1, label="artan adımı var (fiziğe aykırı)")
    ax[k].set(xlabel="Su/bağlayıcı oranı s/b",
              title=f"{ad.capitalize()} model: {bozuk.sum()}/{len(bozuk)} eğri ihlalli")
    ax[k].legend(loc="upper right", fontsize=8.5)
ax[0].set_ylabel("Tahmini dayanım (MPa)")
fig.savefig(KLASOR / "d17_guvenilir_ml_3.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
b = bayrak["Mahalanobis"]
ax[0].scatter(d_yeni[~b], np.abs(hata[~b]), s=7, color=RENK[0], alpha=0.45, linewidths=0, label="İşaretsiz")
ax[0].scatter(d_yeni[b], np.abs(hata[b]), s=7, color=RENK[1], alpha=0.55, linewidths=0,
              label="İşaretli (dağılım dışı)")
ax[0].axvline(esik, color=MUREKKEP, ls="--", lw=1.2, label=f"Eşik = {esik:.2f}")
ax[0].set(xlabel="Eğitim verisine Mahalanobis uzaklığı", ylabel="|Tahmin − ölçüm| (MPa)",
          title="Uzaklık arttıkça hata büyüyor")
ax[0].legend(loc="upper left", markerscale=2)
etiket = [f"{a}–{b_}" for a, b_ in zip(SINIRLAR[:-1], SINIRLAR[1:])]
cubuk = ax[1].bar(etiket, kutu_rmse, color=RENK[0], width=0.6)
for c, n in zip(cubuk, kutu_n):
    ax[1].text(c.get_x() + c.get_width() / 2, c.get_height() + 0.15, f"n = {n}", ha="center", fontsize=8.5,
               color=IKINCIL)
ax[1].set(xlabel="Mahalanobis uzaklığı aralığı", ylabel="RMSE (MPa)", title="Uzaklık aralığına göre RMSE")
fig.savefig(KLASOR / "d17_guvenilir_ml_4.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d17_guvenilir_ml_1.png, _2.png, _3.png, _4.png")
