"""Ders 03 — Yanlılık–varyans ve çapraz doğrulama.

Sentetik bir yorulma (S–N, Wöhler) deney programının verisinde polinom derecesini seçiyoruz.
Özellik log10(S_a), hedef log10(N). Veri sentetiktir: diz noktasında yumuşakça kırılan iki eğimli
bir Basquin eğrisi, döküm partisine özgü rastgele bir kayma ve parti içi saçılmayla üretilir.
Gerçek bir deney kaydı değildir; hiçbir malzemeyi, detay sınıfını ya da standart eğriyi temsil etmez.

Çalıştır:  python d03_capraz_dogrulama.py
Gerekenler: numpy, scikit-learn, matplotlib  (Python 3.12+)
Süre:      yaklaşık 20–40 s (iç içe çapraz doğrulama yaklaşık 900 model eğitir)
Çı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 sklearn.linear_model import LinearRegression, Ridge
from sklearn.model_selection import (GridSearchCV, GroupKFold, KFold, RepeatedKFold, cross_val_score,
                                     learning_curve, validation_curve)
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler, PolynomialFeatures, StandardScaler
from matplotlib.ticker import FixedLocator, FuncFormatter, NullLocator

# --- 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. Veri: sentetik S–N deney programı
S_DIZ, LOGN_DIZ = 200.0, 6.0      # MPa ve log10 N: iki asimptotun kesiştiği diz noktası
M1, M2 = 5.0, 25.0                # diz üstü ve altı ters eğim (N ∝ S^−m)
DELTA = 0.012                     # dizin yumuşaklığı (log10 S biriminde)
TAU, SIGMA_W = 0.15, 0.12         # partiler arası ve parti içi saçılma, log10 N (dekad)
LO, HI = np.log10(170.0), np.log10(400.0)   # deney aralığı: 170–400 MPa
SIGMA2 = TAU**2 + SIGMA_W**2      # yeni bir partiden yeni bir numunenin indirgenemez hatası


def log_omur(x):
    """Gizli 'gerçek' eğri: x = log10 S_a → log10 N (yumuşak dizli iki eğimli Basquin)."""
    u = x - np.log10(S_DIZ)
    return LOGN_DIZ - M1 * u + (M2 - M1) * DELTA * np.logaddexp(0.0, -u / DELTA)


def sn_verisi(parti_duzeyi, numune, rng):
    """Her döküm partisi kendi gerilme düzeyinde `numune` adet deneniyor."""
    n_parti = len(parti_duzeyi)
    x = np.repeat(parti_duzeyi, numune)
    parti = np.repeat(np.arange(n_parti), numune)
    kayma = rng.normal(0.0, TAU, n_parti)                     # partiye özgü kayma (parti etkisi)
    y = log_omur(x) + kayma[parti] + rng.normal(0.0, SIGMA_W, x.size)
    return x, y, parti


rng = np.random.default_rng(42)
duzey = np.linspace(LO, HI, 18)                    # log ölçekte eşit aralıklı 18 gerilme düzeyi
# İç düzeylerde birer parti; eğrinin uçlarını sabitlemek için en düşük ve en yüksek düzeyde üçer parti
parti_duzeyi = np.concatenate([np.repeat(duzey[:1], 3), duzey[1:-1], np.repeat(duzey[-1:], 3)])
x, y, parti = sn_verisi(parti_duzeyi, 4, rng)                    # geliştirme kümesi: 22 parti × 4
x_test, y_test, _ = sn_verisi(rng.uniform(LO, HI, 6), 4, rng)      # test: 6 yeni parti
x_ger, y_ger, _ = sn_verisi(rng.uniform(LO, HI, 1000), 4, rng)     # "gerçek hata": 1000 yeni parti
n_parti = parti_duzeyi.size
X, X_test = x[:, None], x_test[:, None]
print("=== 1. Veri ===")
print(f"Geliştirme: {n_parti} parti, {x.size} numune, {duzey.size} gerilme düzeyi "
      f"({10**LO:.0f}–{10**HI:.0f} MPa), ömür {10**y.min():.1e}–{10**y.max():.1e} çevrim")
print(f"Test: 6 yeni parti, {x_test.size} numune | 'Gerçek hata' örneklemi: 1000 parti, {x_ger.size} numune")
print(f"Saçılma: partiler arası {TAU}, parti içi {SIGMA_W} → indirgenemez hata σ = {np.sqrt(SIGMA2):.3f} dekad")
parti_ort = np.array([y[parti == p].mean() - log_omur(x[parti == p][0]) for p in range(n_parti)])
print(f"Bu {n_parti} partinin ortalama sapmalarının std'si: {parti_ort.std(ddof=1):.3f} "
      f"(beklenen {np.sqrt(TAU**2 + SIGMA_W**2 / 4):.3f})")
rmse_gercek_egri = np.sqrt(np.mean((log_omur(x) - y) ** 2))   # gizli eğrinin kendi "eğitim hatası"
print(f"Gizli gerçek eğrinin bu {x.size} numunedeki RMSE'si: {rmse_gercek_egri:.3f} dekad "
      f"(beklenen σ = {np.sqrt(SIGMA2):.3f})")


# %% 2. Sıfırdan: polinom uydurma ve k-katlı çapraz doğrulama
def z(x):
    """log S'yi deney aralığında [−1, 1]'e taşır; yüksek derecede sayısal kararlılık için gerekli."""
    return (2 * x - (LO + HI)) / (HI - LO)


def polinom_uydur(x, y, derece):
    V = np.vander(z(x), derece + 1, increasing=True)         # sütunlar: 1, z, z², …, z^d
    w, *_ = np.linalg.lstsq(V, y, rcond=None)
    return w


def polinom_tahmin(w, x):
    return np.vander(z(x), len(w), increasing=True) @ w


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


def capraz_dogrulama(x, y, derece, kat):
    """kat[i]: i. numunenin doğrulamaya ayrıldığı kat. Katların RMSE ortalamasını döndürür."""
    hatalar = []
    for k in np.unique(kat):
        egitim, dogrulama = kat != k, kat == k
        w = polinom_uydur(x[egitim], y[egitim], derece)
        hatalar.append(rmse(polinom_tahmin(w, x[dogrulama]), y[dogrulama]))
    return np.mean(hatalar)


K = 5
kat_rastgele = rng.permutation(np.arange(x.size) % K)    # numuneleri katlara rastgele dağıt
kat_grup = (np.arange(n_parti) % K)[parti]               # partileri katlara dağıt (parti bölünmez)


def model(derece, alpha=None):
    """scikit-learn karşılığı. alpha=None → sıradan en küçük kareler, aksi hâlde Ridge."""
    return Pipeline([
        ("olcek_x", MinMaxScaler(feature_range=(-1, 1))),     # z(x) ile aynı iş
        ("poly", PolynomialFeatures(derece, include_bias=False)),
        ("olcek", StandardScaler()),
        ("reg", LinearRegression() if alpha is None else Ridge(alpha=alpha)),
    ])


RMSE_SKOR = "neg_root_mean_squared_error"     # scikit-learn skorları büyük-iyi; RMSE'nin eksisi
kfold, gkfold = KFold(n_splits=K, shuffle=True, random_state=42), GroupKFold(n_splits=K)
cv_sifirdan = capraz_dogrulama(x, y, 4, kat_grup)
cv_sklearn = -cross_val_score(model(4), X, y, groups=parti, cv=gkfold, scoring=RMSE_SKOR).mean()
assert np.isclose(cv_sifirdan, cv_sklearn, rtol=1e-8)   # GroupKFold da partileri sırayla dağıtır
kosul_ham = np.linalg.cond(np.vander(x, 13, increasing=True))
kosul_olcekli = np.linalg.cond(np.vander(z(x), 13, increasing=True))
cv_rastgele = capraz_dogrulama(x, y, 4, kat_rastgele)    # aynı fonksiyon, numune bazında rastgele katlar
print("\n=== 2. Sıfırdan uygulamanın sağlaması ===")
print(f"Sıfırdan 5 katlı CV, derece 4: rastgele katlar {cv_rastgele:.4f}; gruplu katlar {cv_sifirdan:.4f} "
      f"= GroupKFold {cv_sklearn:.4f}")
print(f"Vandermonde koşul sayısı (derece 12): ham log S ile {kosul_ham:.1e}, "
      f"[−1, 1] ölçeğinde {kosul_olcekli:.1e}")

# %% 3. Derece taraması: eğitim, KFold, GroupKFold ve "gerçek" hata
dereceler = np.arange(1, 13)
egitim_h, kfold_h, grup_h, gercek_h, uydurmalar = [], [], [], [], {}
for d in dereceler:
    w = polinom_uydur(x, y, d)
    uydurmalar[d] = w
    egitim_h.append(rmse(polinom_tahmin(w, x), y))
    kfold_h.append(-cross_val_score(model(d), X, y, cv=kfold, scoring=RMSE_SKOR).mean())
    grup_h.append(-cross_val_score(model(d), X, y, groups=parti, cv=gkfold, scoring=RMSE_SKOR).mean())
    gercek_h.append(rmse(polinom_tahmin(w, x_ger), y_ger))
egitim_h, kfold_h, grup_h, gercek_h = map(np.array, (egitim_h, kfold_h, grup_h, gercek_h))
assert np.all(np.diff(egitim_h) <= 1e-12)     # eğitim hatası dereceyle asla artmaz (iç içe modeller)

# %% 4. Yanlılık–varyans: aynı deney planıyla 200 veri kümesi (Monte Carlo)
R = 200
x_izgara = np.linspace(LO, HI, 401)                      # değerlendirme: aralığa düzgün yayılmış gerilmeler
f_izgara = log_omur(x_izgara)
# Tasarım sabit; her sütun yeni partiler ve yeni saçılmayla çekilmiş bir veri kümesi: (88, 200)
Y = (log_omur(x)[:, None] + rng.normal(0.0, TAU, (n_parti, R))[parti]
     + rng.normal(0.0, SIGMA_W, (x.size, R)))
y_yeni = f_izgara[:, None] + rng.normal(0.0, np.sqrt(SIGMA2), (x_izgara.size, R))   # yeni partiler
kat_mc = rng.permutation(np.arange(x.size) % K)          # KFold katları (hız için tüm kümelerde aynı)


def toplu_cv(V, Y, kat):
    """Aynı katlarla 200 veri kümesinin CV hatası; her kat tek bir lstsq ile (sütunlar ayrı kümeler)."""
    h = []
    for k in range(K):
        e, t = kat != k, kat == k
        W = np.linalg.lstsq(V[e], Y[e], rcond=None)[0]
        h.append(np.sqrt(np.mean((V[t] @ W - Y[t]) ** 2, axis=0)))
    return np.mean(h, axis=0)


yanlilik2, varyans, mc_test = [], [], []
mc_kfold, mc_grup, mc_gercek, ornek_egriler = [], [], [], {}
for d in dereceler:
    V = np.vander(z(x), d + 1, increasing=True)
    W = np.linalg.lstsq(V, Y, rcond=None)[0]              # 200 uydurma tek seferde: (d+1, 200)
    F = np.vander(z(x_izgara), d + 1, increasing=True) @ W   # (401, 200) tahmin
    yanlilik2.append(np.mean((F.mean(axis=1) - f_izgara) ** 2))
    varyans.append(np.mean(F.var(axis=1)))
    mc_test.append(np.mean((F - y_yeni) ** 2))
    mc_gercek.append(np.sqrt(SIGMA2 + np.mean((F - f_izgara[:, None]) ** 2, axis=0)))
    mc_kfold.append(toplu_cv(V, Y, kat_mc))
    mc_grup.append(toplu_cv(V, Y, kat_grup))
    if d in (1, 12):
        ornek_egriler[d] = F[:, :15]
yanlilik2, varyans, mc_test = map(np.array, (yanlilik2, varyans, mc_test))
mc_kfold, mc_grup, mc_gercek = map(np.array, (mc_kfold, mc_grup, mc_gercek))   # (12, 200)
toplam = SIGMA2 + yanlilik2 + varyans
assert np.allclose(toplam, mc_test, rtol=0.03)            # ayrışım, Monte Carlo test hatasıyla tutarlı
secim_k, secim_g = mc_kfold.argmin(axis=0), mc_grup.argmin(axis=0)
sutun = np.arange(R)

print("\n=== 3–4. Derece taraması (RMSE, dekad) ve yanlılık–varyans (MSE, dekad², 200 veri kümesi) ===")
print("derece  eğitim  KFold  GroupKFold  gerçek | yanlılık²  varyans  σ²+y²+v  MC test")
for i, d in enumerate(dereceler):
    print(f"{d:6d}  {egitim_h[i]:6.3f}  {kfold_h[i]:5.3f}  {grup_h[i]:10.3f}  {gercek_h[i]:6.3f} | "
          f"{yanlilik2[i]:9.4f}  {varyans[i]:7.4f}  {toplam[i]:7.4f}  {mc_test[i]:7.4f}")
print("--- 200 veri kümesinde KFold ve GroupKFold ---")
for ad, cv, secim in [("KFold     ", mc_kfold, secim_k), ("GroupKFold", mc_grup, secim_g)]:
    sayim = np.bincount(secim + 1, minlength=13)[1:]
    en_sik = np.argsort(sayim)[::-1][:2] + 1
    print(f"{ad}: en sık seçilen dereceler {en_sik[0]} ve {en_sik[1]}; seçilen modelin CV tahmini "
          f"{cv[secim, sutun].mean():.3f}, gerçek hatası {mc_gercek[secim, sutun].mean():.3f}")
print(f"Ortalama eğriler, derece 4 / 12: KFold {mc_kfold[3].mean():.3f} / {mc_kfold[11].mean():.3f}, "
      f"GroupKFold {mc_grup[3].mean():.3f} / {mc_grup[11].mean():.3f}, "
      f"gerçek {mc_gercek[3].mean():.3f} / {mc_gercek[11].mean():.3f}")

# %% 5. Tekrarlı çapraz doğrulama: katlara bölmenin rastgeleliği
rkf = RepeatedKFold(n_splits=5, n_repeats=10, random_state=42)
tekrarli = -cross_val_score(model(4), X, y, scoring=RMSE_SKOR, cv=rkf).reshape(10, 5).mean(axis=1)
grup_tekrar = np.array([-cross_val_score(model(4), X, y, groups=parti, scoring=RMSE_SKOR,
                                         cv=GroupKFold(5, shuffle=True, random_state=s)).mean()
                        for s in range(10)])
print("\n=== 5. Tekrarlı çapraz doğrulama (derece 4, 10 tekrar) ===")
print(f"RepeatedKFold     : tekrarlar {tekrarli.min():.3f}–{tekrarli.max():.3f}, ortalama {tekrarli.mean():.3f}")
print(f"GroupKFold (karış.): tekrarlar {grup_tekrar.min():.3f}–{grup_tekrar.max():.3f}, "
      f"ortalama {grup_tekrar.mean():.3f}")

# %% 6. Öğrenme eğrisi ve doğrulama eğrisi
ogrenme = {}
for d in (1, 8):
    egit, dogr = [], []
    for s in range(3):                     # alt örneklem seçimini üç tekrarla ortala
        boy, e_skor, d_skor = learning_curve(model(d), X, y, groups=parti, cv=gkfold, scoring=RMSE_SKOR,
                                             train_sizes=np.linspace(0.3, 1.0, 6), shuffle=True, random_state=s)
        egit.append(-e_skor.mean(axis=1))
        dogr.append(-d_skor.mean(axis=1))
    ogrenme[d] = (boy, np.mean(egit, axis=0), np.mean(dogr, axis=0))
alfalar = np.logspace(-8, 3, 12)
e_skor, d_skor = validation_curve(model(12, alpha=1.0), X, y, groups=parti, cv=gkfold, scoring=RMSE_SKOR,
                                  param_name="reg__alpha", param_range=alfalar)
vc_egitim, vc_dogr = -e_skor.mean(axis=1), -d_skor.mean(axis=1)
i_alfa = vc_dogr.argmin()
print("\n=== 6. Öğrenme ve doğrulama eğrileri (GroupKFold) ===")
for d, (boy, eg, dg) in ogrenme.items():
    print(f"Derece {d:2d}: {boy[0]}→{boy[-1]} numune; eğitim {eg[0]:.3f}→{eg[-1]:.3f}, "
          f"doğrulama {dg[0]:.3f}→{dg[-1]:.3f}")
print(f"Doğrulama eğrisi (derece 12): α = 1e-8 → {vc_dogr[0]:.3f}, en iyi α = {alfalar[i_alfa]:.0e} → "
      f"{vc_dogr[i_alfa]:.3f}, α = 1e+3 → {vc_dogr[-1]:.3f}")

# %% 7. Hiperparametre araması ve iç içe çapraz doğrulama
izgara = {"poly__degree": list(range(1, 13)), "reg__alpha": [1e-4, 1.0, 100.0]}
arama = GridSearchCV(model(4, alpha=1.0), izgara, cv=GroupKFold(5), scoring=RMSE_SKOR)
arama.fit(X, y, groups=parti)
en_iyi = arama.best_params_
dis_hatalar, secimler = [], []
for egitim, dogrulama in GroupKFold(5).split(X, y, parti):          # dış döngü: yalnız değerlendirme
    ic = GridSearchCV(model(4, alpha=1.0), izgara, cv=GroupKFold(4), scoring=RMSE_SKOR)
    ic.fit(X[egitim], y[egitim], groups=parti[egitim])                # iç döngü: yalnız seçim
    dis_hatalar.append(rmse(ic.predict(X[dogrulama]), y[dogrulama]))
    secimler.append(f"({ic.best_params_['poly__degree']}, {ic.best_params_['reg__alpha']:g})")
son_model = arama.best_estimator_                                    # tüm geliştirme verisiyle yeniden eğitildi
test_rmse = rmse(son_model.predict(X_test), y_test)
gercek_rmse = rmse(son_model.predict(x_ger[:, None]), y_ger)
print("\n=== 7. Hiperparametre araması ve iç içe CV (GroupKFold) ===")
print(f"GridSearchCV: derece {en_iyi['poly__degree']}, α = {en_iyi['reg__alpha']:g}; "
      f"en iyi CV RMSE = {-arama.best_score_:.3f}")
print(f"İç içe CV (dış 5 × iç 4): katlar {' '.join(f'{h:.3f}' for h in dis_hatalar)} → "
      f"ortalama {np.mean(dis_hatalar):.3f}")
print(f"Dış katlarda seçilen (derece, α): {' '.join(secimler)}")
print(f"Son model: test RMSE (6 parti) = {test_rmse:.3f}, gerçek hata (1000 parti) = {gercek_rmse:.3f}")
assert np.isfinite([test_rmse, gercek_rmse, *dis_hatalar]).all()


# %% 8. Grafikler
def log_y(ax, isaretler):
    """Logaritmik y ekseni, okunaklı sabit işaretlerle (0.2, 0.3, … biçiminde)."""
    ax.set_yscale("log")
    ax.yaxis.set_major_locator(FixedLocator(isaretler))
    ax.yaxis.set_major_formatter(FuncFormatter(lambda v, _: f"{v:g}"))
    ax.yaxis.set_minor_locator(NullLocator())


def sn_ekseni(ax):
    ax.set_xscale("log")
    ax.set_yscale("log")
    ax.set_xlim(160, 420)
    ax.set_ylim(10**4.0, 10**8.6)
    ax.set_xticks([170, 200, 250, 300, 400], labels=["170", "200", "250", "300", "400"])
    ax.minorticks_off()
    ax.set(xlabel="Gerilme genliği $S_a$ (MPa)", ylabel="Kırılmaya kadar çevrim $N$")


S_izgara = 10**x_izgara
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].scatter(10**x, 10**y, s=14, color=SOLUK, alpha=.8, label="Numune (sentetik)")
for d, renk in [(1, RENK[1]), (4, RENK[0]), (12, RENK[2])]:
    ax[0].plot(S_izgara, 10**polinom_tahmin(uydurmalar[d], x_izgara), color=renk, lw=1.8, label=f"Derece {d}")
ax[0].plot(S_izgara, 10**f_izgara, color=MUREKKEP, ls="--", lw=1.2, label="Gizli gerçek eğri")
sn_ekseni(ax[0])
ax[0].set_title("Sentetik S–N verisi ve polinom uydurmaları")
ax[0].legend(loc="upper right", fontsize=9)
ax[1].plot(dereceler, egitim_h, "o-", color=RENK[0], ms=4, label="Eğitim")
ax[1].plot(dereceler, grup_h, "s-", color=RENK[1], ms=4, label="Doğrulama (GroupKFold)")
ax[1].plot(dereceler, gercek_h, color=MUREKKEP, ls="--", lw=1.4, label="Gerçek hata (1000 yeni parti)")
ax[1].axhline(np.sqrt(SIGMA2), color=SOLUK, ls=":", lw=1.4, label="İndirgenemez hata σ")
log_y(ax[1], [0.12, 0.15, 0.2, 0.3, 0.5, 1.0])
ax[1].set(xlabel="Polinom derecesi", ylabel="RMSE (dekad, log₁₀ N)", title="Az uyum ve aşırı uyum")
ax[1].set_xticks(dereceler)
ax[1].legend(loc="upper center", fontsize=9)
fig.savefig(KLASOR / "d03_capraz_dogrulama_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for d, renk in [(1, RENK[1]), (12, RENK[2])]:
    egriler = ornek_egriler[d]
    ax[0].plot(S_izgara, 10**egriler, color=renk, lw=0.7, alpha=.45)
    ax[0].plot([], [], color=renk, lw=1.5, label=f"Derece {d}: 15 farklı veri kümesi")
ax[0].plot(S_izgara, 10**f_izgara, color=MUREKKEP, ls="--", lw=1.4, label="Gizli gerçek eğri")
sn_ekseni(ax[0])
ax[0].set_title("Aynı plan, farklı veri kümeleri")
ax[0].legend(loc="upper right", fontsize=9)
ax[1].plot(dereceler, toplam, "o-", color=RENK[0], ms=4, label="σ² + yanlılık² + varyans")
ax[1].plot(dereceler, mc_test, "x", color=MUREKKEP, ms=7, mew=1.5, label="Monte Carlo test MSE")
ax[1].plot(dereceler, yanlilik2, "s-", color=RENK[1], ms=4, label="Yanlılık²")
ax[1].plot(dereceler, varyans, "^-", color=RENK[2], ms=4, label="Varyans")
ax[1].axhline(SIGMA2, color=SOLUK, ls=":", lw=1.4, label="σ² (indirgenemez)")
ax[1].set_yscale("log")
ax[1].set(xlabel="Polinom derecesi", ylabel="MSE (dekad²)", title="Yanlılık–varyans ayrışımı (200 küme)")
ax[1].set_xticks(dereceler)
ax[1].legend(loc="lower right", bbox_to_anchor=(1.0, 0.24), fontsize=8.5)
fig.savefig(KLASOR / "d03_capraz_dogrulama_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].plot(dereceler, mc_kfold.mean(axis=1), "^-", color=RENK[2], ms=4, label="KFold tahmini")
ax[0].plot(dereceler, mc_grup.mean(axis=1), "s-", color=RENK[1], ms=4, label="GroupKFold tahmini")
ax[0].plot(dereceler, mc_gercek.mean(axis=1), color=MUREKKEP, ls="--", lw=1.4, label="Gerçek hata")
log_y(ax[0], [0.15, 0.2, 0.3, 0.5, 0.8])
ax[0].set(xlabel="Polinom derecesi", ylabel="RMSE (dekad), 200 küme ortalaması",
          title="Hangi doğrulama gerçeği izliyor?")
ax[0].set_xticks(dereceler)
ax[0].legend(loc="upper center", fontsize=9)
genislik = 0.4
ax[1].bar(dereceler - genislik / 2, np.bincount(secim_g + 1, minlength=13)[1:], genislik, color=RENK[1],
          label="GroupKFold")
ax[1].bar(dereceler + genislik / 2, np.bincount(secim_k + 1, minlength=13)[1:], genislik, color=RENK[2],
          label="KFold")
ax[1].set(xlabel="Seçilen polinom derecesi", ylabel="Veri kümesi sayısı (200 içinden)",
          title="Seçilen derecenin dağılımı")
ax[1].set_xticks(dereceler)
ax[1].legend(loc="upper center", fontsize=9)
fig.savefig(KLASOR / "d03_capraz_dogrulama_3.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for d, renk in [(1, RENK[1]), (8, RENK[0])]:
    boy, eg, dg = ogrenme[d]
    ax[0].plot(boy, eg, "o-", color=renk, ms=4, label=f"Derece {d}, eğitim")
    ax[0].plot(boy, dg, "s--", color=renk, ms=4, label=f"Derece {d}, doğrulama")
log_y(ax[0], [0.1, 0.15, 0.2, 0.3, 0.5, 1.0])
ax[0].set(xlabel="Eğitimdeki numune sayısı", ylabel="RMSE (dekad)", title="Öğrenme eğrileri (GroupKFold)")
ax[0].legend(loc="upper right", fontsize=9)
ax[1].plot(alfalar, vc_egitim, "o-", color=RENK[0], ms=4, label="Eğitim")
ax[1].plot(alfalar, vc_dogr, "s-", color=RENK[1], ms=4, label="Doğrulama (GroupKFold)")
ax[1].plot(alfalar[i_alfa], vc_dogr[i_alfa], marker="*", ms=13, color=MUREKKEP, ls="none",
           label=f"En iyi α = {alfalar[i_alfa]:g}")
ax[1].set_xscale("log")
log_y(ax[1], [0.1, 0.15, 0.2, 0.3, 0.5, 1.0])
ax[1].set(xlabel="Ridge cezası α", ylabel="RMSE (dekad)", title="Doğrulama eğrisi: derece 12 + Ridge")
ax[1].legend(loc="upper center", fontsize=9)
fig.savefig(KLASOR / "d03_capraz_dogrulama_4.png", dpi=160)
plt.close(fig)
print("Grafikler kaydedildi: d03_capraz_dogrulama_1.png, _2.png, _3.png, _4.png")
