"""Ders 14 — Dizi modelleri: RNN, LSTM ve dikkat.

Zemin ivmesinden (a_g) doğrusal olmayan tek serbestlik dereceli bir yapının yer değiştirme tepkisini (u)
tahmin ediyoruz. Veri tamamen sentetiktir:
  * Yer hareketleri: Kanai–Tajimi süzgecinden geçirilmiş beyaz gürültü × zarf fonksiyonu. PGA 0,1–0,6 g
    (eğitim, doğrulama, test) ve 0,6–0,8 g (eğitim aralığı dışı sınama); dt = 0,02 s, süre 20 s.
  * Yapı: Bouc–Wen histerezisli tek serbestlik dereceli sistem; T = 0,5 s, ζ = %5, α = 0,1, u_y = 2 cm.
    Bütün kayıtlar aynı anda, vektörleştirilmiş RK4 ile çözülür.
Gerçek deprem kaydı ya da gerçek bir yapı değildir; yönetmelik hesabının yerine geçmez.

Modeller: (1) doğrusal referans: son 250 ivme örneğine ridge regresyon (FIR), (2) GRU (PyTorch).
Çalıştır:  python d14_dizi_modelleri.py
Gerekenler: numpy, scipy, matplotlib, torch  (Python 3.12+)
Süre: 2 çekirdekli bir işlemcide birkaç dakika; eğitim süresi makineye göre değişir
Çı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
import torch
from scipy import signal
from torch import nn

# --- 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)
torch.manual_seed(42)

# %% 1. Yer hareketleri: süzülmüş beyaz gürültü × zarf (sentetik)
G = 9.81
DT, N_ADIM = 0.02, 1000                      # 20 s
t = np.arange(N_ADIM) * DT


def yer_hareketi(n, pga_aralik):
    """Kanai–Tajimi süzgeci: H(ω) = (ω_g² + 2iζ_gω_gω) / (ω_g² − ω² + 2iζ_gω_gω); sonra zarf ve PGA ölçeği."""
    f_g = rng.uniform(1.5, 5.0, n)           # zemin baskın frekansı (Hz)
    z_g = rng.uniform(0.4, 0.7, n)           # zemin sönümü
    t1 = rng.uniform(1.0, 2.5, n)            # yükselme süresi
    t2 = t1 + rng.uniform(4.0, 8.0, n)       # kuvvetli hareketin sonu
    c = rng.uniform(0.3, 0.6, n)             # sönümlenme hızı (1/s)
    pga = rng.uniform(*pga_aralik, n)
    m = 2 * N_ADIM                           # FFT ile süzme dairesel evrişimdir; durağan gürültüde sarma zararsız
    om = 2 * np.pi * np.fft.rfftfreq(m, DT)
    wg = 2 * np.pi * f_g[:, None]
    H = (wg**2 + 2j * z_g[:, None] * wg * om) / (wg**2 - om**2 + 2j * z_g[:, None] * wg * om)
    a = np.fft.irfft(np.fft.rfft(rng.normal(size=(n, m)), axis=1) * H, n=m, axis=1)[:, :N_ADIM]
    tt = t[None, :]
    zarf = np.where(tt < t1[:, None], (tt / t1[:, None])**2,
                    np.where(tt <= t2[:, None], 1.0, np.exp(-c[:, None] * (tt - t2[:, None]))))
    a *= zarf
    return a / np.abs(a).max(axis=1, keepdims=True) * pga[:, None] * G, pga


N_EG, N_DOG, N_TEST, N_DIS = 200, 40, 40, 40
a_g, pga = yer_hareketi(N_EG + N_DOG + N_TEST, (0.1, 0.6))
a_dis, pga_dis = yer_hareketi(N_DIS, (0.6, 0.8))            # eğitim aralığı dışı
i_eg = np.arange(N_EG)
i_dog = np.arange(N_EG, N_EG + N_DOG)
i_te = np.arange(N_EG + N_DOG, N_EG + N_DOG + N_TEST)

# %% 2. Bouc–Wen sistemi: m ü + c u̇ + αku + (1−α)kz = −m a_g
T_N, ZETA, ALFA, UY = 0.5, 0.05, 0.1, 0.02  # s, -, -, m
W = 2 * np.pi / T_N


def bouc_wen_rk4(ag, alfa=ALFA, alt_adim=4):
    """Bütün kayıtları (satırlar) birlikte çözer. ż = A u̇ − β|u̇|z − γ u̇|z| (n = 1, A = 1, β = γ)."""
    beta = gamma = 0.5 / UY                 # z'nin üst sınırı A/(β+γ) = UY
    n = ag.shape[0]
    u, v, z = np.zeros(n), np.zeros(n), np.zeros(n)
    U, Z = np.zeros_like(ag), np.zeros_like(ag)
    h = DT / alt_adim

    def f(u, v, z, a):
        return (v,
                -a - 2 * ZETA * W * v - alfa * W**2 * u - (1 - alfa) * W**2 * z,
                v - beta * np.abs(v) * z - gamma * v * np.abs(z))

    for k in range(ag.shape[1] - 1):
        da = ag[:, k + 1] - ag[:, k]        # ivme iki örnek arasında doğrusal değişir
        for s in range(alt_adim):
            a0, a1, a2 = (ag[:, k] + da * (s + r) / alt_adim for r in (0.0, 0.5, 1.0))
            k1 = f(u, v, z, a0)
            k2 = f(u + h / 2 * k1[0], v + h / 2 * k1[1], z + h / 2 * k1[2], a1)
            k3 = f(u + h / 2 * k2[0], v + h / 2 * k2[1], z + h / 2 * k2[2], a1)
            k4 = f(u + h * k3[0], v + h * k3[1], z + h * k3[2], a2)
            u = u + h / 6 * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0])
            v = v + h / 6 * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1])
            z = z + h / 6 * (k1[2] + 2 * k2[2] + 2 * k3[2] + k4[2])
        U[:, k + 1], Z[:, k + 1] = u, z
    return U, Z


u_g, z_g = bouc_wen_rk4(a_g)
u_dis, z_dis = bouc_wen_rk4(a_dis)
u_lin, _ = bouc_wen_rk4(a_g, alfa=1.0)       # α = 1: aynı yapının doğrusal elastik hâli

# Doğrulama 1: doğrusal durumda kesin çözüm (parça parça doğrusal girdi için matris üsteli, lsim)
sistem = signal.StateSpace([[0, 1], [-W**2, -2 * ZETA * W]], [[0], [-1]], [[1, 0]], [[0]])
hata_lin = max(np.abs(signal.lsim(sistem, a_g[i], t)[1] - u_lin[i]).max() / np.abs(u_lin[i]).max()
               for i in range(5))
# Doğrulama 2: doğrusal olmayan durumda adım yarılama
u_ince, _ = bouc_wen_rk4(a_g[:20], alt_adim=8)
hata_yari = np.abs(u_ince - u_g[:20]).max() / np.abs(u_ince).max()

suneklik = np.abs(u_g).max(axis=1) / UY
artik_g = u_g[:, -50:].mean(axis=1)          # son 1 s'nin ortalaması: kalıcı yer değiştirme
print("=== 1. Veri ve sayısal çözüm ===")
print(f"Kayıt: eğitim {N_EG}, doğrulama {N_DOG}, test {N_TEST} (PGA 0.1–0.6 g); aralık dışı {N_DIS} (0.6–0.8 g)")
print(f"Yapı: T = {T_N} s, ζ = {ZETA}, α = {ALFA}, u_y = {UY * 100:.0f} cm; "
      f"akma dayanımı / ağırlık = {W**2 * UY / G:.3f}")
print(f"Süneklik μ = max|u|/u_y: medyan {np.median(suneklik):.2f}, en büyük {suneklik.max():.2f}; "
      f"akan kayıt oranı (μ > 1) = {np.mean(suneklik > 1):.2f}")
print(f"Kalıcı yer değiştirme |u_res|: ortalama {np.mean(np.abs(artik_g)) * 100:.2f} cm, "
      f"en büyük {np.abs(artik_g).max() * 100:.2f} cm")
print(f"RK4 doğrulama: doğrusal durumda kesin çözümden en büyük bağıl fark {hata_lin:.1e}; "
      f"adım yarılamada fark {hata_yari:.1e}")
assert hata_lin < 1e-4 and hata_yari < 1e-3 and np.all(np.isfinite(u_g))

# %% 3. Doğrusal referans: son L ivme örneğine ridge regresyon (FIR), normal denklemlerle sıfırdan
L = 250                                      # 5 s geçmiş
s_a, s_u = a_g[i_eg].std(), u_g[i_eg].std()  # ölçekleme yalnız eğitim verisinden


def gecikmeli(x):
    """(T,) → (T, L): j. sütun x[t − j]; kayıt başlamadan önce yer hareketsiz (sıfır)."""
    xp = np.concatenate([np.zeros(L - 1), x])
    return np.lib.stride_tricks.sliding_window_view(xp, L)[:, ::-1]


def fir_birikim(A_g, U_hedef):
    """Σ FᵀF ve Σ Fᵀy: bütün zaman adımları, kayıt kayıt biriktirilir (λ'dan bağımsız)."""
    FtF, Fty = np.zeros((L, L)), np.zeros(L)
    for a, u in zip(A_g, U_hedef):
        F = np.ascontiguousarray(gecikmeli(a / s_a))
        FtF += F.T @ F
        Fty += F.T @ (u / s_u)
    return FtF, Fty


def fir_coz(FtF, Fty, lam):
    return np.linalg.solve(FtF + lam * np.eye(L), Fty)          # (Σ FᵀF + λI) w = Σ Fᵀy


def fir_tahmin(w, A_g):
    return np.stack([gecikmeli(a / s_a) @ w for a in A_g]) * s_u


def nrmse(p, u):
    return np.sqrt(np.mean((p - u)**2, axis=1)) / np.sqrt(np.mean(u**2, axis=1))


birikim = fir_birikim(a_g[i_eg], u_g[i_eg])
lam_aday = [1e-3, 1e-1, 1e1, 1e3]
dog_hata = [np.median(nrmse(fir_tahmin(fir_coz(*birikim, lam), a_g[i_dog]), u_g[i_dog])) for lam in lam_aday]
lam = lam_aday[int(np.argmin(dog_hata))]
w_fir = fir_coz(*birikim, lam)
w_fir_lin = fir_coz(*fir_birikim(a_g[i_eg], u_lin[i_eg]), lam)
p_fir = fir_tahmin(w_fir, a_g[i_te])
p_fir_dis = fir_tahmin(w_fir, a_dis)
e_fir_lin = nrmse(fir_tahmin(w_fir_lin, a_g[i_te]), u_lin[i_te])
print("\n=== 2. Doğrusal referans (FIR, son 250 örnek, ridge) ===")
print(f"Dürtü tepkisi zaman sabiti 1/(ζω) = {1 / (ZETA * W):.2f} s; L = {L} örnekte ({L * DT:.0f} s) "
      f"zarf %{np.exp(-ZETA * W * L * DT) * 100:.1f}'e iner")
print(f"Doğrulamayla seçilen λ = {lam:g} (adaylar: {', '.join(f'{v:g}' for v in lam_aday)})")
print(f"Doğrusal elastik sistem (α = 1) verisiyle: test NRMSE medyanı = {np.median(e_fir_lin):.3f}")
print(f"Bouc–Wen sistemi verisiyle            : test NRMSE medyanı = {np.median(nrmse(p_fir, u_g[i_te])):.3f}")

# %% 4. Sıfırdan: GRU hücresi ve nedensel dikkat; PyTorch ile aynı sonuç
def sigmoid(x):
    return 1 / (1 + np.exp(-x))


def gru_hucresi(x, h, W_ih, W_hh, b_ih, b_hh):
    """PyTorch sırası: [sıfırlama r, güncelleme z, aday n]."""
    H = h.shape[1]
    gi, gh = x @ W_ih.T + b_ih, h @ W_hh.T + b_hh
    r = sigmoid(gi[:, :H] + gh[:, :H])
    z = sigmoid(gi[:, H:2 * H] + gh[:, H:2 * H])
    n = np.tanh(gi[:, 2 * H:] + r * gh[:, 2 * H:])
    return (1 - z) * n + z * h


def nedensel_dikkat(Q, K, V):
    """softmax(QKᵀ/√d_k)V; her adım yalnız kendisine ve geçmişe bakar."""
    S = Q @ K.T / np.sqrt(Q.shape[-1])
    S = np.where(np.tril(np.ones_like(S)) == 1, S, -np.inf)
    A = np.exp(S - S.max(axis=1, keepdims=True))
    A /= A.sum(axis=1, keepdims=True)
    return A @ V


kucuk = nn.GRU(3, 8, batch_first=True)
xk = torch.randn(4, 6, 3)
with torch.no_grad():
    yk, _ = kucuk(xk)
prm = [p.detach().numpy().astype(np.float64) for p in kucuk.parameters()]   # W_ih, W_hh, b_ih, b_hh
h = np.zeros((4, 8))
for k in range(6):
    h = gru_hucresi(xk[:, k].numpy().astype(np.float64), h, *prm)
fark_gru = np.abs(h - yk[:, -1].numpy()).max()
q, k_, v_ = (torch.randn(7, 4) for _ in range(3))
fark_dikkat = np.abs(nedensel_dikkat(q.numpy(), k_.numpy(), v_.numpy())
                     - nn.functional.scaled_dot_product_attention(q[None], k_[None], v_[None],
                                                                  is_causal=True)[0].numpy()).max()
alici = 1 + (3 - 1) * sum(2**i for i in range(7))                         # çekirdek 3, genişletme 1…64
print("\n=== 3. Sıfırdan GRU hücresi ve dikkat ===")
print(f"NumPy GRU ile nn.GRU arasındaki en büyük fark: {fark_gru:.1e}")
print(f"NumPy nedensel dikkat ile PyTorch arasındaki en büyük fark: {fark_dikkat:.1e}")
print(f"Nedensel genişletilmiş evrişim (çekirdek 3, 7 katman): alıcı alan {alici} örnek = {alici * DT:.2f} s")
assert fark_gru < 1e-5 and fark_dikkat < 1e-5

# %% 5. GRU: çerçeveli girdi, kesik zamanda geri yayılım (TBPTT)
KARE = 5                                     # her GRU adımı 5 örnek (0,1 s) alır, 5 örnek üretir
PARCA = 50                                   # 50 GRU adımı = 5 s'lik parçalar
EPOK = 100


def cerceve(x):
    return torch.tensor(x.reshape(len(x), -1, KARE), dtype=torch.float32)


class GRUModel(nn.Module):
    def __init__(self, gizli=64):
        super().__init__()
        self.gru = nn.GRU(KARE, gizli, batch_first=True)
        self.cikis = nn.Linear(gizli, KARE)

    def forward(self, x, h=None):
        y, h = self.gru(x, h)
        return self.cikis(y), h


def gru_tahmin(model, A_g):
    with torch.no_grad():
        p, _ = model(cerceve(A_g / s_a))                 # sıfır başlangıç durumu, tüm kayıt
    return p.reshape(len(A_g), -1).numpy().astype(np.float64) * s_u


X_eg, Y_eg = cerceve(a_g[i_eg] / s_a), cerceve(u_g[i_eg] / s_u)
model = GRUModel()
opt = torch.optim.Adam(model.parameters(), lr=1e-2)
zamanlayici = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=EPOK, eta_min=1e-4)
egitim_kaybi, dog_kaybi, en_iyi = [], [], (np.inf, None, 0)
for epok in range(EPOK):
    h, toplam = None, 0.0
    for s in range(0, X_eg.shape[1], PARCA):
        tahmin, h = model(X_eg[:, s:s + PARCA], h)
        h = h.detach()                                  # durum taşınır, gradyan parça sınırında kesilir
        kayip = ((tahmin - Y_eg[:, s:s + PARCA])**2).mean()
        opt.zero_grad()
        kayip.backward()
        nn.utils.clip_grad_norm_(model.parameters(), 1.0)    # gradyan kırpma
        opt.step()
        toplam += kayip.item()
    zamanlayici.step()
    egitim_kaybi.append(toplam / (X_eg.shape[1] // PARCA))
    if (epok + 1) % 10 == 0:
        dk = np.mean(((gru_tahmin(model, a_g[i_dog]) - u_g[i_dog]) / s_u)**2)
        dog_kaybi.append((epok + 1, dk))
        if dk < en_iyi[0]:
            en_iyi = (dk, {k: v.clone() for k, v in model.state_dict().items()}, epok + 1)
model.load_state_dict(en_iyi[1])
p_gru = gru_tahmin(model, a_g[i_te])
p_gru_dis = gru_tahmin(model, a_dis)
print("\n=== 4. GRU eğitimi ===")
print(f"Parametre sayısı: {sum(p.numel() for p in model.parameters())}; "
      f"{EPOK} epok × {X_eg.shape[1] // PARCA} parça; en iyi doğrulama epoku {en_iyi[2]}")
print(f"Eğitim kaybı (ölçekli MSE): ilk epok {egitim_kaybi[0]:.3f}, son epok {egitim_kaybi[-1]:.4f}; "
      f"en iyi doğrulama MSE {en_iyi[0]:.4f}")

# %% 6. Değerlendirme: NRMSE, tepe ve kalıcı yer değiştirme
def tepe_hatasi(p, u):
    return (np.abs(p).max(axis=1) - np.abs(u).max(axis=1)) / np.abs(u).max(axis=1)


def artik(x):
    return x[:, -50:].mean(axis=1)


zayif = pga[i_te] < 0.25
print("\n=== 5. Test kayıtları (PGA 0.1–0.6 g) ===")
print(f"{'Model':10s} {'NRMSE med.':>11s} {'zayıf':>7s} {'kuvvetli':>9s} {'|tepe hatası|':>14s} "
      f"{'kalıcı y.d. hatası':>19s}")
for ad, p in [("Doğrusal", p_fir), ("GRU", p_gru)]:
    e = nrmse(p, u_g[i_te])
    print(f"{ad:10s} {np.median(e):11.3f} {np.median(e[zayif]):7.3f} {np.median(e[~zayif]):9.3f} "
          f"{np.mean(np.abs(tepe_hatasi(p, u_g[i_te]))) * 100:13.1f}% "
          f"{np.mean(np.abs(artik(p) - artik(u_g[i_te]))) * 100:15.2f} cm")
print(f"Gerçek kalıcı yer değiştirme (test): ortalama |u_res| = {np.mean(np.abs(artik(u_g[i_te]))) * 100:.2f} cm; "
      f"GRU ile korelasyon {np.corrcoef(artik(p_gru), artik(u_g[i_te]))[0, 1]:.3f}")
k_te = int(np.argmax(np.abs(u_g[i_te]).max(axis=1)))
e_gru_te = nrmse(p_gru, u_g[i_te])
print(f"Testteki en büyük tepe: gerçek {np.abs(u_g[i_te[k_te]]).max() * 100:.1f} cm, "
      f"GRU {np.abs(p_gru[k_te]).max() * 100:.1f} cm, doğrusal {np.abs(p_fir[k_te]).max() * 100:.1f} cm; "
      f"bu kayıtta GRU NRMSE {e_gru_te[k_te]:.3f}")
j_te = int(np.argmax(pga[i_te]))                # Şekil 1'deki kayıt: testte PGA'sı en büyük olan
u_j, g_j, f_j = u_g[i_te[j_te]] * 100, p_gru[j_te] * 100, p_fir[j_te] * 100
print(f"Şekil 1 kaydı (PGA {pga[i_te[j_te]]:.2f} g): en büyük |u| gerçek {np.abs(u_j).max():.2f}, "
      f"GRU {np.abs(g_j).max():.2f}, doğrusal {np.abs(f_j).max():.2f} cm; "
      f"kalıcı y.d. gerçek {u_j[-50:].mean():.2f}, GRU {g_j[-50:].mean():.2f} cm")
sira = int(np.sum(e_gru_te >= e_gru_te[j_te]))
print(f"   bu kayıtta GRU NRMSE {e_gru_te[j_te]:.3f} (testte büyükten küçüğe {sira}. "
      f"/ {len(e_gru_te)}); testteki en kötü GRU NRMSE {e_gru_te.max():.3f}")
print("\n=== 6. Eğitim aralığı dışı (PGA 0.6–0.8 g) ===")
for ad, p in [("Doğrusal", p_fir_dis), ("GRU", p_gru_dis)]:
    print(f"{ad:10s} NRMSE medyanı {np.median(nrmse(p, u_dis)):.3f}, "
          f"tepe hatası ortalaması {np.mean(tepe_hatasi(p, u_dis)) * 100:+.1f}% (işaretli)")
print(f"Aralık dışı kayıtlarda süneklik medyanı {np.median(np.abs(u_dis).max(axis=1) / UY):.2f} "
      f"(eğitimde {np.median(suneklik[i_eg]):.2f})")
k_en = int(np.argmax(np.abs(u_dis).max(axis=1)))
print(f"En büyük tepe: gerçek {np.abs(u_dis[k_en]).max() * 100:.1f} cm, "
      f"GRU {np.abs(p_gru_dis[k_en]).max() * 100:.1f} cm; "
      f"GRU'nun aralık dışı kayıtlardaki en büyük tepe tahmini {np.abs(p_gru_dis).max() * 100:.1f} cm")
assert np.all(np.isfinite(p_gru)) and np.median(nrmse(p_gru, u_g[i_te])) < np.median(nrmse(p_fir, u_g[i_te]))

# %% 7. Grafikler
j, jj = i_te[j_te], j_te                     # testteki en kuvvetli kayıt
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained", width_ratios=[1.6, 1])
ax[0].plot(t, a_g[j] / G, color=SOLUK, lw=1)
ax[0].set(xlabel="Zaman (s)", ylabel=r"Yer ivmesi $a_g$ (g)", title=f"Test kaydı: PGA = {pga[j]:.2f} g")
kuvvet = (ALFA * W**2 * u_g[j] + (1 - ALFA) * W**2 * z_g[j]) / G
ax[1].plot(u_g[j] * 100, kuvvet, color=MUREKKEP, lw=1)
ax[1].set(xlabel="Yer değiştirme u (cm)", ylabel="Geri çağıran kuvvet / ağırlık",
          title="Bouc–Wen histerezisi (gerçek)")
fig.savefig(KLASOR / "d14_dizi_modelleri_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(figsize=(9, 4.8), layout="constrained")
ax.plot(t, u_g[j] * 100, color=MUREKKEP, ls="--", lw=1.4, label="Gerçek (RK4)")
ax.plot(t, p_gru[jj] * 100, color=RENK[0], lw=1.6, label="GRU")
ax.plot(t, p_fir[jj] * 100, color=RENK[1], ls=":", lw=1.6, label="Doğrusal FIR")
ax.axhline(0, color=IKINCIL, lw=0.6)
ax.set(xlabel="Zaman (s)", ylabel="Yer değiştirme u (cm)", title="Tepki: gerçek, GRU ve doğrusal referans")
ax.legend(loc="upper right", ncols=3)
fig.savefig(KLASOR / "d14_dizi_modelleri_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
tepe_g, tepe_d = np.abs(u_g[i_te]).max(axis=1) * 100, np.abs(u_dis).max(axis=1) * 100
ax[0].scatter(tepe_g, np.abs(p_fir).max(axis=1) * 100, s=22, color=RENK[1], marker="^", label="Doğrusal (test)")
ax[0].scatter(tepe_g, np.abs(p_gru).max(axis=1) * 100, s=22, color=RENK[0], label="GRU (test)")
ax[0].scatter(tepe_d, np.abs(p_gru_dis).max(axis=1) * 100, s=26, facecolor="white", edgecolor=RENK[0],
              label="GRU (aralık dışı)")
sinir = max(tepe_d.max(), tepe_g.max()) * 1.05
ax[0].plot([0, sinir], [0, sinir], color=MUREKKEP, ls="--", lw=1.2, label="Tam isabet")
ax[0].set(xlabel="Gerçek tepe |u| (cm)", ylabel="Tahmin edilen tepe |u| (cm)", title="Tepe yer değiştirme",
          xlim=(0, sinir), ylim=(0, sinir))
ax[0].legend(loc="upper left")
ax[1].axvspan(0.6, 0.8, color=SOLUK, alpha=0.15, lw=0, label="Eğitim aralığı dışı")
ax[1].scatter(pga[i_te], nrmse(p_fir, u_g[i_te]), s=22, color=RENK[1], marker="^", label="Doğrusal")
ax[1].scatter(pga_dis, nrmse(p_fir_dis, u_dis), s=22, color=RENK[1], marker="^")
ax[1].scatter(pga[i_te], nrmse(p_gru, u_g[i_te]), s=22, color=RENK[0], label="GRU")
ax[1].scatter(pga_dis, nrmse(p_gru_dis, u_dis), s=26, facecolor="white", edgecolor=RENK[0])
ax[1].set(xlabel="PGA (g)", ylabel="NRMSE", title="Kayıt başına hata", ylim=(0, 1.25))
ax[1].legend(loc="upper left", ncols=3, fontsize=9)
fig.savefig(KLASOR / "d14_dizi_modelleri_3.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].semilogy(np.arange(1, EPOK + 1), egitim_kaybi, color=RENK[0], label="Eğitim (parça ortalaması)")
ax[0].semilogy(*zip(*dog_kaybi), "o-", color=RENK[1], ms=4, lw=1.4, label="Doğrulama (tam kayıt)")
ax[0].set(xlabel="Epok", ylabel="MSE (ölçekli)", title="GRU öğrenme eğrisi")
ax[0].legend(loc="upper right")
r_g, r_f, r_t = artik(p_gru) * 100, artik(p_fir) * 100, artik(u_g[i_te]) * 100
sinir = np.abs(np.concatenate([r_g, r_f, r_t])).max() * 1.1
ax[1].plot([-sinir, sinir], [-sinir, sinir], color=MUREKKEP, ls="--", lw=1.2, label="Tam isabet")
ax[1].scatter(r_t, r_f, s=22, color=RENK[1], marker="^", label="Doğrusal")
ax[1].scatter(r_t, r_g, s=22, color=RENK[0], label="GRU")
ax[1].set(xlabel="Gerçek kalıcı yer değiştirme (cm)", ylabel="Tahmin (cm)", title="Kalıcı yer değiştirme (test)",
          xlim=(-sinir, sinir), ylim=(-sinir, sinir))
ax[1].legend(loc="upper left")
fig.savefig(KLASOR / "d14_dizi_modelleri_4.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d14_dizi_modelleri_1.png, _2.png, _3.png, _4.png")
