"""Ders 04 — Düzenlileştirme ve özellik mühendisliği.

Sentetik beton karışımı verisinden basınç dayanımını tahmin ediyoruz. Veri sentetiktir: dayanım,
Abrams yasası (su/etkin bağlayıcı oranı), EN 1992-1-1'deki yaş katsayısı β_cc(t) = exp(s·(1 − √(28/t)))
ve %7 log-normal saçılmayla üretilir; agregalar, kalıp numarası ve ortam sıcaklığı dayanımı etkilemez.
Gerçek bir deney veri kümesi değildir.

Çalıştır:  python d04_duzenlilestirme.py
Gerekenler: numpy, pandas, scikit-learn, matplotlib  (Python 3.12+)
Süre:      yaklaşık 15–30 s
Çıktılar:  terminale sayılar, aynı klasöre üç PNG grafiği
"""
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 sklearn.compose import ColumnTransformer, TransformedTargetRegressor
from sklearn.impute import SimpleImputer
from sklearn.linear_model import ElasticNetCV, Lasso, LassoCV, LinearRegression, Ridge, RidgeCV, lasso_path
from sklearn.model_selection import KFold, cross_val_predict, cross_validate
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, PolynomialFeatures, StandardScaler

# --- 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 beton karışımları (kurs genelindeki ortak üretici, 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


rng = np.random.default_rng(42)
df = beton_verisi(500, rng, eksik_oran=0.05)
y = df["dayanim_mpa"].to_numpy()
HAM_SAYISAL = ["cimento", "curuf", "ucucu_kul", "su", "super_akiskan", "iri_agrega", "ince_agrega",
               "yas_gun", "kalip_no", "ortam_sicakligi"]
TIP2, TIP3 = "CEM II/A-LL 42,5 N", "CEM III/A 32,5 N"
print("=== 1. Veri ===")
print(f"{len(df)} karışım, {df.shape[1] - 1} özellik sütunu; eksik süperakışkanlaştırıcı: "
      f"{df.super_akiskan.isna().sum()} satır (%{100 * df.super_akiskan.isna().mean():.1f})")
print(f"Dayanım {y.min():.1f}–{y.max():.1f} MPa (ortalama {y.mean():.1f}); çimento tipleri: "
      + ", ".join(f"{t.split()[0] + ' ' + t.split()[1].split('/')[0]} {k}"
                  for t, k in df.cimento_tipi.value_counts().items()))


# %% 2. Özellik mühendisliği: su/bağlayıcı oranı, yaş özelliği, log hedef
def ozellik_ekle(d):
    """Satır satır hesaplanan fiziksel özellikler (veriden parametre öğrenmez → sızıntı yok)."""
    d = d.copy()
    d["sb"] = d.su / (d.cimento + 0.6 * d.curuf + 0.4 * d.ucucu_kul)   # su / etkin bağlayıcı
    d["g_yas"] = 1 - np.sqrt(28 / d.yas_gun)                           # ln β_cc = s · g(t)
    d["g_x_II"] = d.g_yas * (d.cimento_tipi == TIP2)                   # tipe bağlı s için etkileşim
    d["g_x_III"] = d.g_yas * (d.cimento_tipi == TIP3)
    return d


dfo = ozellik_ekle(df)


def on_isleme(sayisal, kodlayici=None):
    """Sayısal: eksik doldur + standartlaştır; kategorik: one-hot (varsayılan)."""
    if kodlayici is None:
        kodlayici = OneHotEncoder(drop="first", sparse_output=False)
    sayisal_hat = Pipeline([("doldur", SimpleImputer(strategy="median")), ("olcek", StandardScaler())])
    return ColumnTransformer([
        ("sayisal", sayisal_hat, sayisal),
        ("kategorik", kodlayici, ["cimento_tipi"]),
    ])


def log_hedef(regresor):
    """Model log(dayanım)'ı öğrenir; tahminler exp ile MPa'ya geri döner."""
    return TransformedTargetRegressor(regressor=regresor, func=np.log, inverse_func=np.exp)


def polinom_hatti(regresor):
    """Fizik bilgisi olmadan: ham sayısal sütunların bütün 2. derece terimleri (90 özellik)."""
    return log_hedef(Pipeline([("on_isleme", on_isleme(HAM_SAYISAL)),
                               ("poly", PolynomialFeatures(2, include_bias=False)),
                               ("olcek2", StandardScaler()), ("reg", regresor)]))


MUH_B = ["sb", "g_yas", "super_akiskan"]
MUH_C = MUH_B + ["g_x_II", "g_x_III"]
alfa_izgara = np.logspace(-5, -1, 25)
modeller = {
    "(a) Ham sütunlar + one-hot, MPa": Pipeline([("on_isleme", on_isleme(HAM_SAYISAL)),
                                                  ("reg", LinearRegression())]),
    "(b) s/b, g(t), süperakışkanlaştırıcı + one-hot, log": log_hedef(Pipeline([("on_isleme", on_isleme(MUH_B)),
                                                                     ("reg", LinearRegression())])),
    "(c) (b) + tip × g(t) etkileşimi, log": log_hedef(Pipeline([("on_isleme", on_isleme(MUH_C)),
                                                               ("reg", LinearRegression())])),
    "(d) Ham 2. derece polinom, OLS": polinom_hatti(LinearRegression()),
    "(e) (d) + RidgeCV": polinom_hatti(RidgeCV(alphas=np.logspace(-3, 3, 25))),
    "(f) (d) + LassoCV": polinom_hatti(LassoCV(alphas=alfa_izgara, max_iter=20000)),
    "(g) (d) + ElasticNetCV (l1_ratio 0,5)": polinom_hatti(ElasticNetCV(l1_ratio=0.5, alphas=alfa_izgara,
                                                                         max_iter=20000)),
}
cv = KFold(n_splits=5, shuffle=True, random_state=42)
SKOR = {"MAE": "neg_mean_absolute_error", "RMSE": "neg_root_mean_squared_error", "R2": "r2"}
sonuc = {}
for ad, model in modeller.items():
    r = cross_validate(model, dfo, y, cv=cv, scoring=SKOR)
    sonuc[ad] = {m: (s * r[f"test_{m}"].mean(), r[f"test_{m}"].std())
                 for m, s in [("MAE", -1), ("RMSE", -1), ("R2", 1)]}
tahmin_a = cross_val_predict(modeller["(a) Ham sütunlar + one-hot, MPa"], dfo, y, cv=cv)
tahmin_c = cross_val_predict(modeller["(c) (b) + tip × g(t) etkileşimi, log"], dfo, y, cv=cv)
log_artik_c = np.log(y) - np.log(tahmin_c)
print("\n=== 2. Beş katlı çapraz doğrulama (ortalama ± std) ===")
print(f"{'model':51s}  {'MAE (MPa)':>11s}  {'RMSE (MPa)':>11s}  {'R²':>11s}")
for ad, s in sonuc.items():
    print(f"{ad:51s}  {s['MAE'][0]:5.2f}±{s['MAE'][1]:.2f}  {s['RMSE'][0]:6.2f}±{s['RMSE'][1]:.2f}  "
          f"{s['R2'][0]:.3f}±{s['R2'][1]:.3f}")
print(f"(c) modelinin log ölçekte artık std'si: {log_artik_c.std():.3f} (üreticideki saçılma: 0.07)")


def dilim_artik(tahmin):
    """Artık (gerçek − tahmin) ortalaması, tahminin altı eşit sayılı diliminde: eğrilik göstergesi."""
    sinir = np.quantile(tahmin, np.linspace(0, 1, 7))
    hangi = np.clip(np.searchsorted(sinir, tahmin, side="right") - 1, 0, 5)
    return np.array([np.mean((y - tahmin)[hangi == k]) for k in range(6)])


for ad, tahmin in [("(a)", tahmin_a), ("(c)", tahmin_c)]:
    print(f"{ad} artık ortalaması, tahminin 6 diliminde (küçükten büyüğe, MPa): "
          + " ".join(f"{v:+.2f}" for v in dilim_artik(tahmin)))
assert sonuc["(c) (b) + tip × g(t) etkileşimi, log"]["R2"][0] > sonuc["(a) Ham sütunlar + one-hot, MPa"]["R2"][0]

# %% 3. Geniş özellik kümesi: fizik + ham + ilgisiz sütunlar + kareler ve etkileşimler
d = dfo.copy()
# Not: kolaylık için doldurma ve standartlaştırma burada bütün veriyle yapılıyor. Bu, Pipeline'ın önlediği
# türden küçük bir sızıntıdır (bu veride etkisi ihmal edilebilir); dürüst CV için 2. bölümdeki hatlara bakın.
d["super_akiskan"] = d.super_akiskan.fillna(d.super_akiskan.median())
tip2, tip3 = (d.cimento_tipi == TIP2).astype(float), (d.cimento_tipi == TIP3).astype(float)
genis = pd.DataFrame({
    "s/b": d.sb, "g(t)": d.g_yas, "(s/b)²": d.sb**2, "g(t)²": d.g_yas**2, "s/b·g(t)": d.sb * d.g_yas,
    "CEM II": tip2, "CEM III": tip3, "CEM II·g(t)": d.g_x_II, "CEM III·g(t)": d.g_x_III,
    "süperakışkanlaştırıcı": d.super_akiskan, "çimento": d.cimento, "su": d.su, "cüruf": d.curuf,
    "uçucu kül": d.ucucu_kul, "iri agrega": d.iri_agrega, "ince agrega": d.ince_agrega,
    "kalıp no": d.kalip_no, "ortam sıcaklığı": d.ortam_sicakligi,
})
ILGISIZ = ["iri agrega", "ince agrega", "kalıp no", "ortam sıcaklığı"]
Xg = genis.to_numpy()
Xs = (Xg - Xg.mean(axis=0)) / Xg.std(axis=0)        # standartlaştırılmış (ortalama 0, std 1)
ly = np.log(y)
lyc = ly - ly.mean()                                 # merkezlenmiş hedef: sabit terim ayrı


# %% 4. Sıfırdan Ridge: kapalı biçim ve SVD büzülmesi
def ridge_kapali(X, y, alfa):
    """(XᵀX + αI) w = Xᵀy; X ve y merkezlenmiş varsayılır (sabit terim cezalanmaz)."""
    return np.linalg.solve(X.T @ X + alfa * np.eye(X.shape[1]), X.T @ y)


alfa_r = RidgeCV(alphas=np.logspace(-3, 3, 61)).fit(Xs, ly).alpha_
w_ridge = ridge_kapali(Xs, lyc, alfa_r)
w_ridge_skl = Ridge(alpha=alfa_r).fit(Xs, ly).coef_
assert np.allclose(w_ridge, w_ridge_skl, atol=1e-10)
U, dvals, Vt = np.linalg.svd(Xs, full_matrices=False)
buzulme = dvals**2 / (dvals**2 + alfa_r)                     # her temel yöndeki büzülme çarpanı
w_svd = Vt.T @ (buzulme / dvals * (U.T @ lyc))              # aynı çözüm, SVD ile
assert np.allclose(w_svd, w_ridge, atol=1e-10)
w_ols = np.linalg.lstsq(Xs, lyc, rcond=None)[0]


# %% 5. Sıfırdan Lasso: koordinat inişi ve yumuşak eşikleme
def yumusak_esik(a, t):
    return np.sign(a) * np.maximum(np.abs(a) - t, 0.0)


def lasso_koordinat(X, y, alfa, tol=1e-10, en_cok=20000):
    """min (1/2n)‖y − Xw‖² + α‖w‖₁ ; X standartlaştırılmış (‖x_j‖²/n = 1), y merkezlenmiş."""
    n, p = X.shape
    w, artik = np.zeros(p), y.copy()                 # artik = y − Xw
    for adim in range(1, en_cok + 1):
        en_buyuk_degisim = 0.0
        for j in range(p):
            eski = w[j]
            rho = X[:, j] @ artik / n + eski         # j. katsayı dışarıdayken korelasyon
            w[j] = yumusak_esik(rho, alfa)
            if w[j] != eski:
                artik -= X[:, j] * (w[j] - eski)
                en_buyuk_degisim = max(en_buyuk_degisim, abs(w[j] - eski))
        if en_buyuk_degisim < tol:
            return w, adim
    return w, en_cok


# %% 6. Lasso yolu, LassoCV ve bir-standart-hata kuralı
lasso_cv = LassoCV(alphas=np.logspace(-5, -0.5, 60), cv=cv, max_iter=50000).fit(Xs, ly)
mse_ort = lasso_cv.mse_path_.mean(axis=1)
mse_se = lasso_cv.mse_path_.std(axis=1) / np.sqrt(cv.get_n_splits())
i_min = mse_ort.argmin()
alfa_min = lasso_cv.alphas_[i_min]
alfa_1se = lasso_cv.alphas_[mse_ort <= mse_ort[i_min] + mse_se[i_min]].max()   # en sade iyi model
yol_alfa, yol_katsayi, _ = lasso_path(Xs, lyc, alphas=np.logspace(-5, -0.5, 80), max_iter=50000)
w_lasso, adim_kd = lasso_koordinat(Xs, lyc, alfa_1se)
w_lasso_skl = Lasso(alpha=alfa_1se, tol=1e-12, max_iter=100000).fit(Xs, ly).coef_
assert np.allclose(w_lasso, w_lasso_skl, atol=1e-6)
w_min = Lasso(alpha=alfa_min, max_iter=50000).fit(Xs, ly).coef_
ilgisiz_j = [list(genis.columns).index(c) for c in ILGISIZ]
secilen = [c for c, w in zip(genis.columns, w_lasso) if w != 0]

print("\n=== 3. Sıfırdan Ridge ve Lasso (18 standart özellik, hedef log f) ===")
print(f"Ridge, α = {alfa_r:.3g} (RidgeCV): kapalı biçim = scikit-learn = SVD çözümü "
      f"(en büyük fark {np.abs(w_ridge - w_ridge_skl).max():.1e})")
print(f"Tekil değerler d: {dvals.max():.1f} … {dvals.min():.3f}; büzülme çarpanı d²/(d²+α): "
      f"{buzulme.max():.3f} … {buzulme.min():.3f}; etkin serbestlik derecesi {buzulme.sum():.1f} / {len(dvals)}")
print(f"‖w‖: en küçük kareler {np.linalg.norm(w_ols):.2f}, Ridge {np.linalg.norm(w_ridge):.2f}")
print(f"Lasso koordinat inişi = scikit-learn: en büyük fark {np.abs(w_lasso - w_lasso_skl).max():.1e} "
      f"({adim_kd} tur)")

print("\n=== 4. Lasso yolu ve α seçimi ===")
print(f"LassoCV en küçük CV hatası: α = {alfa_min:.2e}, sıfır olmayan {np.sum(w_min != 0)}/18; "
      f"ilgisiz sütunların en büyük |katsayısı| {np.abs(w_min[ilgisiz_j]).max():.4f}")
print(f"Bir-standart-hata kuralı:   α = {alfa_1se:.2e}, sıfır olmayan {len(secilen)}/18; "
      f"ilgisiz sütunlar: {'hepsi sıfır' if np.all(w_lasso[ilgisiz_j] == 0) else 'sıfır değil'}")
secim_metni = [f"{c} {w:+.3f}" for c, w in zip(genis.columns, w_lasso) if w != 0]
print("Seçilenler: " + ", ".join(secim_metni[:4]) + ",")
print("            " + ", ".join(secim_metni[4:]))
giris = [(yol_alfa[np.abs(yol_katsayi[j]) > 0].max(), c) for j, c in enumerate(genis.columns)]
giris.sort(reverse=True)
print("Giriş sırası (ilk 7): " + ", ".join(c for _, c in giris[:7]) + f"; ilgisiz sütunlar en erken α = "
      f"{max(a for a, c in giris if c in ILGISIZ):.1e}'te")
sade_model = log_hedef(Pipeline([("olcek", StandardScaler()), ("reg", Lasso(alpha=alfa_1se, max_iter=50000))]))
r_1se = cross_validate(sade_model, genis, y, cv=cv, scoring=SKOR)
print(f"Bu sade modelin CV'si (MPa): RMSE {-r_1se['test_RMSE'].mean():.2f}, R² {r_1se['test_R2'].mean():.3f}")

# %% 7. Ölçekleme neden önemli: aynı Ridge cezası, ölçekli ve ölçeksiz
OLCEK_KUME = [c for c in genis.columns if c not in ("(s/b)²", "g(t)²", "s/b·g(t)")]   # kare/çarpım yok
print(f"\n=== 5. Ölçekleme: Ridge(α = 1), {len(OLCEK_KUME)} özellik, hedef log f ===")
olcek_sonuc = {}
for ad, adimlar in [("ölçeksiz", [("reg", Ridge(alpha=1.0))]),
                    ("StandardScaler ile", [("olcek", StandardScaler()), ("reg", Ridge(alpha=1.0))])]:
    model = log_hedef(Pipeline(adimlar))
    r = cross_validate(model, genis[OLCEK_KUME], y, cv=cv, scoring=SKOR)
    model.fit(genis[OLCEK_KUME], y)
    katsayi = model.regressor_.named_steps["reg"].coef_
    if "olcek" in model.regressor_.named_steps:
        katsayi = katsayi / model.regressor_.named_steps["olcek"].scale_     # özgün birimlere çevir
    olcek_sonuc[ad] = katsayi
    print(f"{ad:19s}: CV RMSE {-r['test_RMSE'].mean():.2f} MPa, R² {r['test_R2'].mean():.3f}; "
          f"s/b katsayısı {katsayi[OLCEK_KUME.index('s/b')]:+.3f}, "
          f"çimento katsayısı {katsayi[OLCEK_KUME.index('çimento')]:+.5f} 1/(kg/m³)")
print(f"Gerçek s/b etkisi (Abrams, log ölçek): −ln 7 = {-np.log(7):.3f}; standart sapmalar: "
      f"s/b {genis['s/b'].std():.3f}, çimento {genis['çimento'].std():.1f} kg/m³")

# %% 8. Kategorik kodlama: one-hot ve sıralı
print("\n=== 6. Çimento tipinin kodlanması, model (b) ===")
TIP1 = "CEM I 42,5 R"
for ad, kodlayici in [("one-hot (2 kukla sütun)", None),
                      ("sıralı 0-1-2 (I < II < III)", OrdinalEncoder(categories=[[TIP1, TIP2, TIP3]])),
                      ("sıralı, karışık sıra (II < I < III)", OrdinalEncoder(categories=[[TIP2, TIP1, TIP3]]))]:
    model = log_hedef(Pipeline([("on_isleme", on_isleme(MUH_B, kodlayici)), ("reg", LinearRegression())]))
    r = cross_validate(model, dfo, y, cv=cv, scoring=SKOR)
    print(f"{ad:35s}: RMSE {-r['test_RMSE'].mean():.2f} MPa, R² {r['test_R2'].mean():.3f}")


# %% 9. Grafikler
def tahmin_grafigi(ax, tahmin, renk, baslik):
    ax.scatter(y, tahmin, s=12, color=renk, alpha=.55)
    ax.plot([5, 70], [5, 70], color=MUREKKEP, ls="--", lw=1.2, label="Kusursuz tahmin")
    ax.set(xlim=(5, 70), ylim=(5, 70), xlabel="Gerçek dayanım (MPa)", ylabel="CV tahmini (MPa)", title=baslik)
    ax.set_aspect("equal")
    ax.legend(loc="upper left")


fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
sa, sc = sonuc["(a) Ham sütunlar + one-hot, MPa"], sonuc["(c) (b) + tip × g(t) etkileşimi, log"]
tahmin_grafigi(ax[0], tahmin_a, RENK[1],
               f"(a) Ham sütunlar: RMSE {sa['RMSE'][0]:.2f} MPa, R² {sa['R2'][0]:.3f}")
tahmin_grafigi(ax[1], tahmin_c, RENK[0],
               f"(c) Fiziksel özellikler: RMSE {sc['RMSE'][0]:.2f} MPa, R² {sc['R2'][0]:.3f}")
fig.savefig(KLASOR / "d04_duzenlilestirme_1.png", dpi=160)
plt.close(fig)

# L1 ve L2 kısıt bölgeleri: iki katsayılı bir en küçük kareler probleminin kontur çizgileri
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
A = np.array([[1.0, 0.6], [0.6, 1.0]])                   # kayıp eğriliği (ilişkili iki özellik)
w_hat = np.array([1.2, 0.25])                             # cezasız çözüm
g1, g2 = np.meshgrid(np.linspace(-1.6, 1.8, 300), np.linspace(-1.6, 1.8, 300))
G = np.stack([g1 - w_hat[0], g2 - w_hat[1]], axis=-1)
kayip = np.einsum("...i,ij,...j->...", G, A, G)
t_kisit = 0.8
aci = np.linspace(0, 2 * np.pi, 20001)                    # sınır üzerinde ince ızgara: kısıtlı çözüm
cozumler = {}
for eksen, ad in [(ax[0], "L2 (Ridge)"), (ax[1], "L1 (Lasso)")]:
    if ad.startswith("L2"):
        sinir = np.c_[t_kisit * np.cos(aci), t_kisit * np.sin(aci)]
    else:
        sinir = np.c_[t_kisit * np.sign(np.cos(aci)) * np.cos(aci)**2,     # |w1| + |w2| = t
                      t_kisit * np.sign(np.sin(aci)) * np.sin(aci)**2]
    deger = np.einsum("...i,ij,...j->...", sinir - w_hat, A, sinir - w_hat)
    w_kisitli = sinir[deger.argmin()]
    cozumler[ad] = w_kisitli
    seviye = deger.min() * np.array([0.1, 0.35, 1.0, 2.0])          # 1.0: kısıta değen kontur
    eksen.contour(g1, g2, kayip, levels=seviye, colors=SOLUK, linewidths=0.8)
    eksen.fill(sinir[:, 0], sinir[:, 1], color=RENK[0], alpha=0.18, lw=0)
    eksen.plot(sinir[:, 0], sinir[:, 1], color=RENK[0], lw=1.5, label=f"{ad} kısıt bölgesi")
    eksen.plot(*w_hat, "o", color=MUREKKEP, ms=6, label="Cezasız çözüm")
    eksen.plot(*w_kisitli, "*", color=RENK[1], ms=14,
               label=f"Kısıtlı çözüm ({w_kisitli[0]:.3f}, {w_kisitli[1]:.3f})")
    eksen.axhline(0, color=IKINCIL, lw=0.8)
    eksen.axvline(0, color=IKINCIL, lw=0.8)
    eksen.set(xlim=(-1.6, 1.8), ylim=(-1.6, 1.8), xlabel="$w_1$", ylabel="$w_2$",
              title=f"{ad}: kayıp konturları ve kısıt")
    eksen.set_aspect("equal")
    eksen.legend(loc="lower left", fontsize=8.5)
fig.savefig(KLASOR / "d04_duzenlilestirme_2.png", dpi=160)
plt.close(fig)
w2, w1 = cozumler["L2 (Ridge)"], cozumler["L1 (Lasso)"]
print(f"\nL1/L2 örneği (grafik 2): cezasız ({w_hat[0]:.2f}, {w_hat[1]:.2f}); "
      f"L2 kısıtlı ({w2[0]:.3f}, {w2[1]:.3f}), boy {np.linalg.norm(w2):.3f}; "
      f"L1 kısıtlı ({w1[0]:.3f}, {w1[1]:.3f})")

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
onemli = ["s/b", "g(t)", "CEM III·g(t)", "CEM III", "CEM II·g(t)", "süperakışkanlaştırıcı",
          "s/b·g(t)"]
for j, ad in enumerate(genis.columns):
    if ad in onemli:
        ax[0].plot(yol_alfa, yol_katsayi[j], color=RENK[onemli.index(ad)], lw=1.8, label=ad)
    elif ad in ILGISIZ:
        ax[0].plot(yol_alfa, yol_katsayi[j], color=MUREKKEP, lw=1.0, ls=":")
    else:
        ax[0].plot(yol_alfa, yol_katsayi[j], color=SOLUK, lw=0.8, alpha=.7)
ax[0].plot([], [], color=MUREKKEP, lw=1.0, ls=":", label="İlgisiz 4 sütun")
ax[0].plot([], [], color=SOLUK, lw=0.8, label="Diğer 7 özellik")
for a, ls in [(alfa_min, "--"), (alfa_1se, "-.")]:
    ax[0].axvline(a, color=IKINCIL, ls=ls, lw=1)
ax[0].set_xscale("log")
ax[0].set(xlabel="Lasso cezası α", ylabel="Standart katsayı (log f)",
          title="Lasso yolu: özellikler sırayla giriyor")
ax[0].set_ylim(-0.37, 0.175)                     # alt bant lejant için boş kalsın
ax[0].legend(loc="lower center", fontsize=8, ncol=3, frameon=True, facecolor="white", edgecolor="none",
             framealpha=1)
ax[1].errorbar(lasso_cv.alphas_, mse_ort, yerr=mse_se, color=RENK[0], ecolor=SOLUK, elinewidth=0.8, capsize=0,
               marker="o", ms=3, lw=1.5, label="CV hatası ± 1 standart hata")
ax[1].axvline(alfa_min, color=IKINCIL, ls="--", lw=1, label=f"En küçük CV hatası, α = {alfa_min:.1e}")
ax[1].axvline(alfa_1se, color=IKINCIL, ls="-.", lw=1, label=f"Bir-standart-hata kuralı, α = {alfa_1se:.1e}")
ax[1].set_xscale("log")
ax[1].set_yscale("log")
ax[1].set(xlabel="Lasso cezası α", ylabel="CV MSE (log f)²", title="LassoCV ile α seçimi")
ax[1].legend(loc="upper left", fontsize=8.5, frameon=True, facecolor="white", edgecolor="none", framealpha=1)
fig.savefig(KLASOR / "d04_duzenlilestirme_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d04_duzenlilestirme_1.png, _2.png, _3.png")
