"""Ders 15 — Gauss süreçleri ve belirsizlik.

Üç sentetik örnek:
  A) "Pahalı simülasyon": tek serbestlik dereceli bir sistemin dinamik büyütme katsayısı
     D(r) = 1/√((1−r²)² + (2ζr)²), ζ = 0,25. Fonksiyonu biliyoruz; her noktası saatler süren bir
     hesapmış gibi davranıp yalnız 8 gürültülü değerini (σ = 0,05) kullanıyoruz.
  B) Güvenilirlik: g = R − k·V². R: bir cephe panelinin taşıyabildiği rüzgâr basıncı (kPa, lognormal),
     V: yıllık en büyük rüzgâr hızı (m/s, Gumbel). Göçme olasılığı 10⁶ örnekli Monte Carlo, sayısal
     integral ve AK-MCS (GP vekil model + U fonksiyonu) ile. Katsayılar eğitim amaçlıdır; bir
     yönetmeliğin rüzgâr hesabı değildir.
  C) Yorulma deneyini andıran, saçılımı gerilmeyle değişen sentetik S–N verisi: kantil regresyon,
     bölünmüş uyumlu tahmin (split conformal), CQR ve bootstrap topluluğu; deneysel kapsama oranları.

Çalıştır:  python d15_gauss_surecleri.py
Gerekenler: numpy, scipy, scikit-learn, matplotlib  (Python 3.12+)
Süre: yaklaşık 1 dakika
Çıktılar: terminale sayılar, aynı klasöre dört 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 scipy import integrate, stats
from scipy.linalg import solve_triangular
from scipy.optimize import minimize
from scipy.stats import qmc
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel, WhiteKernel

# --- 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
rng = np.random.default_rng(42)


# %% 1. Çekirdekler ve sıfırdan Gauss süreci regresyonu
def kare_ustel(xa, xb, l, sf):
    """Kare üstel (RBF) çekirdek: sf² · exp(−(x − x')² / (2ℓ²))."""
    return sf**2 * np.exp(-0.5 * (xa[:, None] - xb[None, :])**2 / l**2)


def matern52(xa, xb, l, sf):
    """Matérn 5/2 çekirdeği: sf² (1 + √5 r/ℓ + 5r²/(3ℓ²)) exp(−√5 r/ℓ)."""
    r = np.abs(xa[:, None] - xb[None, :]) / l
    return sf**2 * (1 + np.sqrt(5) * r + 5 * r**2 / 3) * np.exp(-np.sqrt(5) * r)


def gp_sonsal(x, y, xs, l, sf, sn, cekirdek=kare_ustel):
    """Sonsal ortalama, sonsal varyans ve log marjinal olabilirlik (Cholesky ile)."""
    K = cekirdek(x, x, l, sf) + sn**2 * np.eye(len(x))
    L = np.linalg.cholesky(K)                                     # K = L Lᵀ
    alfa = solve_triangular(L.T, solve_triangular(L, y, lower=True), lower=False)   # K⁻¹y
    Ks = cekirdek(x, xs, l, sf)
    mu = Ks.T @ alfa                                              # k*ᵀ K⁻¹ y
    v = solve_triangular(L, Ks, lower=True)
    var = sf**2 - np.sum(v**2, axis=0)                            # k(x*,x*) − k*ᵀ K⁻¹ k*
    lml = -0.5 * y @ alfa - np.sum(np.log(np.diag(L))) - 0.5 * len(x) * np.log(2 * np.pi)
    return mu, var, lml


def en_iyi_hiper(x, y, sn, cekirdek=kare_ustel):
    """σ_n sabitken ℓ ve σ_f'yi log marjinal olabilirliği en büyütecek biçimde bulur."""
    def eksi_lml(th):
        l, sf = np.exp(th)
        return -gp_sonsal(x, y, x[:1], l, sf, sn, cekirdek)[2]
    sonuc = None
    for l0 in [0.1, 0.3, 1.0, 3.0]:                               # birkaç başlangıç noktası
        r = minimize(eksi_lml, np.log([l0, 1.0]), method="L-BFGS-B",
                     bounds=[(np.log(1e-2), np.log(1e2))] * 2)
        if sonuc is None or r.fun < sonuc.fun:
            sonuc = r
    return np.exp(sonuc.x), -sonuc.fun


# %% 2. Örnek A: 8 noktalı "pahalı simülasyon"
def buyutme(r, zeta=0.25):
    return 1 / np.sqrt((1 - r**2)**2 + (2 * zeta * r)**2)


SN = 0.05                                                         # simülasyon gürültüsü (bilinen)
x = np.sort(qmc.LatinHypercube(d=1, seed=rng).random(8)[:, 0] * 3.0)   # Latin hiperküp tasarımı
y = buyutme(x) + rng.normal(0, SN, x.size)
y_ort = y.mean()                                                  # sabit ortalama: örneklem ortalaması
yc = y - y_ort
xs = np.linspace(0, 3.0, 400)
gercek = buyutme(xs)

(l_opt, sf_opt), lml_opt = en_iyi_hiper(x, yc, SN)
mu, var, _ = gp_sonsal(x, yc, xs, l_opt, sf_opt, SN)
sd = np.sqrt(np.maximum(var, 0))
rmse_A = np.sqrt(np.mean((mu + y_ort - gercek)**2))
kapsama_A = np.mean(np.abs(mu + y_ort - gercek) <= 2 * sd)

# scikit-learn: aynı çekirdek ve aynı (sabit) gürültüyle hiperparametre en iyileme
cek = ConstantKernel(1.0, (1e-4, 1e4)) * RBF(1.0, (1e-2, 1e2))
skl = GaussianProcessRegressor(cek, alpha=SN**2, n_restarts_optimizer=10, random_state=42).fit(x[:, None], yc)
sf_skl = np.sqrt(skl.kernel_.k1.constant_value)
l_skl = skl.kernel_.k2.length_scale
# hiperparametreler sabitken iki uygulama birebir aynı sonucu vermeli
sabit = GaussianProcessRegressor(ConstantKernel(sf_opt**2, "fixed") * RBF(l_opt, "fixed"),
                                 alpha=SN**2, optimizer=None).fit(x[:, None], yc)
mu_skl, sd_skl = sabit.predict(xs[:, None], return_std=True)
fark_mu, fark_sd = np.abs(mu - mu_skl).max(), np.abs(sd - sd_skl).max()
# gürültüyü de öğrenmeye çalışırsak (WhiteKernel): 8 noktayla zor
beyaz = GaussianProcessRegressor(ConstantKernel(1.0, (1e-4, 1e4)) * RBF(1.0, (1e-2, 1e2))
                                 + WhiteKernel(1e-2, (1e-8, 1.0)), n_restarts_optimizer=10,
                                 random_state=42).fit(x[:, None], yc)
sn_beyaz = np.sqrt(beyaz.kernel_.k2.noise_level)

print("=== 1. Örnek A: 8 noktalı pahalı simülasyon (dinamik büyütme katsayısı) ===")
print("Tasarım noktaları r =", " ".join(f"{v:.2f}" for v in x))
print(f"Sıfırdan GP (RBF, σ_n = {SN} sabit): ℓ = {l_opt:.3f}, σ_f = {sf_opt:.3f}, log ML = {lml_opt:.3f}")
print(f"scikit-learn GPR           : ℓ = {l_skl:.3f}, σ_f = {sf_skl:.3f}, "
      f"log ML = {skl.log_marginal_likelihood_value_:.3f}")
print(f"Aynı hiperparametrelerle en büyük fark: ortalama {fark_mu:.1e}, std {fark_sd:.1e}")
print(f"Gerçek eğriye göre RMSE = {rmse_A:.3f}; ±2σ bandının gerçek eğriyi kapsadığı oran = {kapsama_A:.3f}")
print(f"En büyük sonsal std = {sd.max():.3f} (r = {xs[np.argmax(sd)]:.2f}); "
      f"rezonans tepesi r = {np.sqrt(1 - 2 * 0.25**2):.3f}, D = {buyutme(np.sqrt(1 - 2 * 0.25**2)):.3f}")
for l_den in [0.1, 1.5]:
    m_, v_, lml_ = gp_sonsal(x, yc, xs, l_den, sf_opt, SN)
    rmse_ = np.sqrt(np.mean((m_ + y_ort - gercek)**2))
    print(f"ℓ = {l_den:4.1f} (σ_f aynı): log ML = {lml_:8.3f}, RMSE = {rmse_:.3f}")
(l_m, sf_m), lml_m = en_iyi_hiper(x, yc, SN, matern52)
m_m, _, _ = gp_sonsal(x, yc, xs, l_m, sf_m, SN, matern52)
print(f"Matérn 5/2 : ℓ = {l_m:.3f}, σ_f = {sf_m:.3f}, log ML = {lml_m:.3f}, "
      f"RMSE = {np.sqrt(np.mean((m_m + y_ort - gercek)**2)):.3f}")
print(f"Gürültü de öğrenilirse (WhiteKernel): σ_n = {sn_beyaz:.4f} (gerçek {SN})")
assert fark_mu < 1e-8 and fark_sd < 1e-8
assert abs(skl.log_marginal_likelihood_value_ - lml_opt) < 1e-3

# %% 3. Örnek B: güvenilirlik, Monte Carlo ve AK-MCS
R_ORT, R_DK = 2.0, 0.15            # kPa, değişim katsayısı
V_ORT, V_DK = 25.0, 0.20           # m/s
K_BASINC = 0.5 * 1.25 * 1.3 / 1000  # ½·ρ·c / 1000 → kPa/(m/s)²; c = 1,3 basınç ve esinti katsayısı
s_lnR = np.sqrt(np.log(1 + R_DK**2))
m_lnR = np.log(R_ORT) - s_lnR**2 / 2
b_V = V_DK * V_ORT * np.sqrt(6) / np.pi
loc_V = V_ORT - np.euler_gamma * b_V


def g_fiziksel(R, V):
    return R - K_BASINC * V**2       # g ≤ 0: göçme


def g_u(u):
    """Standart normal uzaydaki u = (u1, u2) noktasını fiziksel değişkenlere çevirip g'yi hesaplar."""
    R = np.exp(m_lnR + s_lnR * u[:, 0])
    V = stats.gumbel_r.isf(stats.norm.sf(u[:, 1]), loc_V, b_V)
    return g_fiziksel(R, V)


pf_integral, _ = integrate.quad(
    lambda v: stats.norm.cdf((np.log(K_BASINC * v**2) - m_lnR) / s_lnR) * stats.gumbel_r.pdf(v, loc_V, b_V),
    0, 200, limit=200)
N_MC = 1_000_000
U = rng.standard_normal((N_MC, 2))
g_mc = g_u(U)
pf_mc = np.mean(g_mc <= 0)
se_mc = np.sqrt(pf_mc * (1 - pf_mc) / N_MC)

def lbfgs(amac, theta0, bounds):
    """scikit-learn'ün varsayılanıyla aynı L-BFGS-B. g neredeyse doğrusal olduğundan olabilirlik yüzeyi çok
    düzdür; çizgi araması erken bitince varsayılan uyarı yazar, burada en iyi nokta sessizce döner."""
    r = minimize(amac, theta0, method="L-BFGS-B", jac=True, bounds=bounds)
    return r.x, r.fun


# AK-MCS: küçük bir Latin hiperküp tasarımıyla başla, U = |μ|/σ en küçük olan örneği ekle
n0 = 12
X_t = qmc.LatinHypercube(d=2, seed=rng).random(n0) * 10 - 5     # [−5, 5]² kutusu (u uzayı)
y_t = g_u(X_t)
gecmis = []
for adim in range(60):
    # alpha (nugget) küçük kalmalı: büyürse tasarım noktalarında σ sıfıra inmez ve U ≥ 2 hiç sağlanmaz
    vekil = GaussianProcessRegressor(ConstantKernel(1.0, (1e-3, 1e4)) * RBF([1.0, 1.0], (1e-2, 1e3)),
                                     alpha=1e-8, normalize_y=True, optimizer=lbfgs, n_restarts_optimizer=3,
                                     random_state=42).fit(X_t, y_t)
    mu_g, sd_g = np.empty(N_MC), np.empty(N_MC)
    for s in range(0, N_MC, 100_000):                           # belleği korumak için parça parça
        mu_g[s:s + 100_000], sd_g[s:s + 100_000] = vekil.predict(U[s:s + 100_000], return_std=True)
    U_fonk = np.abs(mu_g) / np.maximum(sd_g, 1e-12)
    j = np.argmin(U_fonk)
    gecmis.append((len(y_t), np.mean(mu_g <= 0), U_fonk[j]))
    if U_fonk[j] >= 2:                                          # durma ölçütü: min U ≥ 2
        break
    X_t = np.vstack([X_t, U[j]])
    y_t = np.append(y_t, g_u(U[j:j + 1]))
pf_ak = gecmis[-1][1]
yanlis = int(np.sum((mu_g <= 0) != (g_mc <= 0)))

print("\n=== 2. Örnek B: güvenilirlik ve aktif öğrenme (AK-MCS) ===")
print(f"Sayısal integral       : P_f = {pf_integral:.4e}  (β = {-stats.norm.ppf(pf_integral):.3f})")
print(f"Monte Carlo, 10⁶ örnek : P_f = {pf_mc:.4e}  (%95 aralık {pf_mc - 1.96 * se_mc:.4e} – "
      f"{pf_mc + 1.96 * se_mc:.4e}, değişim katsayısı {se_mc / pf_mc:.3f})")
for n_c, pf_c, u_c in gecmis:
    print(f"   AK-MCS: {n_c:2d} çağrı → P_f = {pf_c:.4e}, en küçük U = {u_c:.3f}")
print(f"AK-MCS sonucu: P_f = {pf_ak:.4e}, gerçek fonksiyon çağrısı = {len(y_t)} "
      f"(başlangıç {n0} + {len(y_t) - n0} ekleme); yanlış sınıflanan örnek = {yanlis}")
assert len(gecmis) < 60 and abs(pf_ak - pf_mc) < 3 * se_mc

# %% 4. Örnek C: değişen saçılım, kantil regresyon ve uyumlu tahmin
S_MIN, S_MAX = 80.0, 320.0           # gerilme genliği (MPa)


def sn_verisi(n):
    logS = rng.uniform(np.log10(S_MIN), np.log10(S_MAX), n)
    sacilim = 0.08 + 0.30 * (np.log10(S_MAX) - logS) / (np.log10(S_MAX) - np.log10(S_MIN))
    logN = 12.4 - 3.0 * logS + sacilim * rng.normal(size=n)       # eğim 3, saçılım düşük gerilmede büyük
    return logS, logN


x_eg, y_eg = sn_verisi(500)          # eğitim
x_kal, y_kal = sn_verisi(500)        # kalibrasyon (yalnız uyumlu tahmin için)
x_te, y_te = sn_verisi(5000)         # test: kapsamayı ölçmek için
ALFA = 0.10                          # hedef kapsama 1 − α = %90
gb = dict(n_estimators=150, max_depth=2, learning_rate=0.05, min_samples_leaf=20, random_state=42)
nokta = GradientBoostingRegressor(**gb).fit(x_eg[:, None], y_eg)
q_alt = GradientBoostingRegressor(loss="quantile", alpha=ALFA / 2, **gb).fit(x_eg[:, None], y_eg)
q_ust = GradientBoostingRegressor(loss="quantile", alpha=1 - ALFA / 2, **gb).fit(x_eg[:, None], y_eg)

n_kal = len(y_kal)
k_sira = int(np.ceil((n_kal + 1) * (1 - ALFA)))                 # ⌈(n+1)(1−α)⌉. en küçük skor
skor = np.abs(y_kal - nokta.predict(x_kal[:, None]))           # bölünmüş uyumlu tahmin skoru
q_hat = np.sort(skor)[k_sira - 1]
E = np.maximum(q_alt.predict(x_kal[:, None]) - y_kal, y_kal - q_ust.predict(x_kal[:, None]))   # CQR skoru
Q_hat = np.sort(E)[k_sira - 1]

p_te = nokta.predict(x_te[:, None])
alt_te, ust_te = q_alt.predict(x_te[:, None]), q_ust.predict(x_te[:, None])
B = 25
tahminler = np.empty((B, x_te.size))
for b in range(B):                                              # bootstrap topluluğu
    idx = rng.integers(0, x_eg.size, x_eg.size)
    tahminler[b] = GradientBoostingRegressor(**{**gb, "random_state": b}).fit(
        x_eg[idx, None], y_eg[idx]).predict(x_te[:, None])
b_alt, b_ust = np.percentile(tahminler, [5, 95], axis=0)

yontemler = {
    "Bölünmüş uyumlu": (p_te - q_hat, p_te + q_hat),
    "Kantil GBR": (alt_te, ust_te),
    "CQR": (alt_te - Q_hat, ust_te + Q_hat),
    "Bootstrap (25 model)": (b_alt, b_ust),
}
kenarlar = np.log10(np.geomspace(S_MIN, S_MAX, 5))               # 4 gerilme aralığı
bolge = np.clip(np.digitize(x_te, kenarlar[1:-1]), 0, 3)
print("\n=== 3. Örnek C: değişen saçılımlı yorulma verisi, hedef kapsama %90 ===")
print(f"Kalibrasyon: n = {n_kal}, sıra k = ⌈(n+1)(1−α)⌉ = {k_sira}; q̂ = {q_hat:.3f}, "
      f"CQR düzeltmesi Q̂ = {Q_hat:.3f}")
etiket = [f"{10**kenarlar[i]:.0f}–{10**kenarlar[i + 1]:.0f}" for i in range(4)]
print("Gerilme aralıkları (MPa): " + ", ".join(etiket))
print(f"{'Yöntem':22s} {'kapsama':>8s}   aralık başına kapsama        ortalama genişlik (log10 N)")
kapsama_tablo = {}
for ad, (alt, ust) in yontemler.items():
    icinde = (y_te >= alt) & (y_te <= ust)
    kb = [icinde[bolge == i].mean() for i in range(4)]
    kapsama_tablo[ad] = kb
    print(f"{ad:22s} {icinde.mean():8.3f}   " + " ".join(f"{v:.3f}" for v in kb)
          + f"      {np.mean(ust - alt):.3f}")
assert np.isfinite(q_hat) and abs(np.mean(np.abs(y_te - p_te) <= q_hat) - 0.9) < 0.03

# %% 5. Grafikler
# Şekil 1: önsel örnekler
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained", sharey=True)
xg = np.linspace(0, 3, 300)
z = rng.standard_normal((xg.size, 3))
for a, (cekirdek, ad) in zip(ax, [(kare_ustel, "Kare üstel (RBF), ℓ = 0.5"), (matern52, "Matérn 5/2, ℓ = 0.5")]):
    Kp = cekirdek(xg, xg, 0.5, 1.0) + 1e-8 * np.eye(xg.size)
    ornek = np.linalg.cholesky(Kp) @ z
    a.fill_between(xg, -2, 2, color=RENK[0], alpha=0.10, lw=0, label=r"Önsel ±2σ ($\sigma_f$ = 1)")
    for i in range(3):
        a.plot(xg, ornek[:, i], color=RENK[i], lw=1.6, label=f"Örnek {i + 1}")
    a.set(xlabel="x", title=ad, ylim=(-3.2, 2.6))
ax[0].set_ylabel("f(x)")
ax[0].legend(loc="lower center", ncols=4, fontsize=8.5)
fig.savefig(KLASOR / "d15_gauss_surecleri_1.png", dpi=160)
plt.close(fig)

# Şekil 2: sonsal ve uzunluk ölçeğinin etkisi
fig, ax = plt.subplots(2, 2, figsize=(10, 7.0), layout="constrained")
for a, l_den, baslik in [(ax[0, 0], l_opt, f"En büyük olabilirlik: ℓ = {l_opt:.2f}"),
                         (ax[0, 1], 0.1, "ℓ = 0.1: çok kısa"), (ax[1, 0], 1.5, "ℓ = 1.5: çok uzun")]:
    m_, v_, _ = gp_sonsal(x, yc, xs, l_den, sf_opt, SN)
    s_ = np.sqrt(np.maximum(v_, 0))
    a.fill_between(xs, m_ + y_ort - 2 * s_, m_ + y_ort + 2 * s_, color=RENK[0], alpha=0.18, lw=0,
                   label="Ortalama ± 2σ")
    a.plot(xs, gercek, color=MUREKKEP, ls="--", lw=1.3, label="Gerçek eğri")
    a.plot(xs, m_ + y_ort, color=RENK[0], label="GP ortalaması")
    a.scatter(x, y, s=34, color=SOLUK, zorder=5, label="Simülasyon (8 nokta)")
    a.set(xlabel=r"Frekans oranı $r = \omega/\omega_n$", ylabel="Dinamik büyütme D", title=baslik,
          ylim=(-0.6, 3.0))
ax[0, 0].legend(loc="upper right", fontsize=9)
l_izgara = np.geomspace(0.05, 3, 120)
lml_izgara = [gp_sonsal(x, yc, x[:1], lv, sf_opt, SN)[2] for lv in l_izgara]
ax[1, 1].semilogx(l_izgara, lml_izgara, color=RENK[0])
ax[1, 1].axvline(l_opt, color=MUREKKEP, ls=":", lw=1.2, label=f"En iyi ℓ = {l_opt:.2f}")
ax[1, 1].set(xlabel="Uzunluk ölçeği ℓ (log)", ylabel="log marjinal olabilirlik",
             title=r"Marjinal olabilirlik ($\sigma_f$ ve $\sigma_n$ sabit)",
             ylim=(max(min(lml_izgara), -60), lml_opt + 5))
ax[1, 1].legend(loc="lower left")
fig.savefig(KLASOR / "d15_gauss_surecleri_2.png", dpi=160)
plt.close(fig)

# Şekil 3: AK-MCS
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
u1, u2 = np.meshgrid(np.linspace(-5, 5, 220), np.linspace(-5, 5, 220))
izgara = np.column_stack([u1.ravel(), u2.ravel()])
g_iz = g_u(izgara).reshape(u1.shape)
mu_iz = vekil.predict(izgara).reshape(u1.shape)
alt_kume = U[:8000]
ax[0].contourf(u1, u2, g_iz, levels=[g_iz.min() - 1, 0], colors=[RENK[1]], alpha=0.10)
ax[0].scatter(alt_kume[:, 0], alt_kume[:, 1], s=1, color=SOLUK, alpha=0.25, rasterized=True)
ax[0].contour(u1, u2, g_iz, levels=[0], colors=MUREKKEP, linestyles="--", linewidths=1.4)
ax[0].contour(u1, u2, mu_iz, levels=[0], colors=RENK[0], linewidths=1.6)
ax[0].plot(X_t[:n0, 0], X_t[:n0, 1], "s", ms=6, mfc="white", mec=RENK[1], mew=1.5, ls="none",
           label=f"Başlangıç tasarımı ({n0})")
ax[0].plot(X_t[n0:, 0], X_t[n0:, 1], "o", ms=6, color=RENK[2], ls="none",
           label=f"AK-MCS eklemeleri ({len(y_t) - n0})")
ax[0].plot([], [], color=MUREKKEP, ls="--", lw=1.4, label="Gerçek sınır g = 0")
ax[0].plot([], [], color=RENK[0], lw=1.6, label="GP sınırı μ = 0")
ax[0].text(-2.6, 4.4, "göçme bölgesi (g ≤ 0)", ha="center", va="center", fontsize=9, color=IKINCIL)
ax[0].set(xlabel="u₁ (dayanım R, standart normal)", ylabel="u₂ (rüzgâr hızı V, standart normal)",
          title="Standart normal uzayda sınır durum", xlim=(-5, 5), ylim=(-5, 5))
ax[0].legend(loc="lower left", fontsize=8.5)
cagri = [h[0] for h in gecmis]
ax[1].fill_between([cagri[0] - 0.5, cagri[-1] + 0.5], 1e3 * (pf_mc - 1.96 * se_mc), 1e3 * (pf_mc + 1.96 * se_mc),
                   color=SOLUK, alpha=0.25, lw=0, label="MC (10⁶ örnek) %95 aralığı")
ax[1].axhline(1e3 * pf_integral, color=MUREKKEP, ls="--", lw=1.2, label="Sayısal integral")
ax[1].plot(cagri, [1e3 * h[1] for h in gecmis], "-o", color=RENK[0], ms=5, label="AK-MCS tahmini")
ax[1].set(xlabel="Gerçek fonksiyon çağrısı", ylabel=r"Göçme olasılığı $P_f$ (×10⁻³)",
          title=r"$P_f$ tahmininin yakınsaması")
ax[1].legend(loc="lower right")
fig.savefig(KLASOR / "d15_gauss_surecleri_3.png", dpi=160)
plt.close(fig)

# Şekil 4: uyumlu tahmin
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
sira = np.argsort(x_te)
S_te = 10**x_te[sira]
ax[0].scatter(10**x_te[:1500], y_te[:1500], s=4, color=SOLUK, alpha=0.5, label="Test verisi (sentetik)")
ax[0].plot(S_te, (p_te - q_hat)[sira], color=RENK[1], lw=1.4, label="Bölünmüş uyumlu (sabit genişlik)")
ax[0].plot(S_te, (p_te + q_hat)[sira], color=RENK[1], lw=1.4)
ax[0].plot(S_te, (alt_te - Q_hat)[sira], color=RENK[0], lw=1.6, label="CQR (uyarlanır genişlik)")
ax[0].plot(S_te, (ust_te + Q_hat)[sira], color=RENK[0], lw=1.6)
ax[0].plot(S_te, p_te[sira], color=MUREKKEP, lw=1.0, ls=":", label="Nokta tahmini")
ax[0].set(xscale="log", xlabel="Gerilme genliği S (MPa)", ylabel="log₁₀ N (çevrim)", title="%90 tahmin aralıkları")
ax[0].legend(loc="upper right", fontsize=8.5)
genislik = 0.2
merkez = np.arange(4)
for i, (ad, renk) in enumerate([("Bölünmüş uyumlu", RENK[1]), ("CQR", RENK[0]), ("Kantil GBR", RENK[2]),
                                ("Bootstrap (25 model)", RENK[3])]):
    ax[1].bar(merkez + (i - 1.5) * genislik, kapsama_tablo[ad], width=genislik, color=renk, label=ad)
ax[1].axhline(0.9, color=MUREKKEP, ls="--", lw=1.2, label="Hedef %90")
ax[1].set_xticks(merkez, etiket)
ax[1].set(xlabel="Gerilme aralığı (MPa)", ylabel="Deneysel kapsama", ylim=(0, 1.32),
          yticks=np.arange(0, 1.01, 0.2), title="Gerilme aralığına göre kapsama")
ax[1].legend(loc="upper center", ncols=3, fontsize=8)
fig.savefig(KLASOR / "d15_gauss_surecleri_4.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d15_gauss_surecleri_1.png, _2.png, _3.png, _4.png")
