"""Ders 02 — Doğrusal regresyon ve gradyan inişi.

Çelik bir çekme numunesinin elastik bölge ölçümlerinden elastisite modülünü (E)
tahmin ediyoruz. Veri sentetiktir: E = 206 GPa, sıfır kayması 4 MPa ve
ölçüm gürültüsüyle üretilir. Gerçek bir deney kaydı değildir.

Çalıştır:  python d02_dogrusal_regresyon.py
Gerekenler: numpy, scipy, scikit-learn, matplotlib  (Python 3.12+)
Çıktılar:  terminale sayılar, aynı klasöre üç 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 stats
from sklearn.linear_model import LinearRegression

# --- 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: elastik bölgede gerinim ve gerilme ölçümleri
rng = np.random.default_rng(42)
E_GERCEK = 206_000.0       # MPa (206 GPa)
B_GERCEK = 4.0             # MPa, yükleme başındaki sıfır kayması
n = 80
eps = np.sort(rng.uniform(0.10e-3, 1.50e-3, n))          # gerinim (birimsiz)
sigma = E_GERCEK * eps + B_GERCEK + rng.normal(0, 3.0, n)  # gerilme (MPa)
print("=== 1. Veri ===")
print(f"Örnek sayısı: {n}, gerinim aralığı: {eps.min()*1e3:.2f}–{eps.max()*1e3:.2f} ‰, "
      f"gerilme aralığı: {sigma.min():.0f}–{sigma.max():.0f} MPa")

# %% 2. Kapalı biçimli çözüm: en küçük kareler (normal denklemler)
# Tasarım matrisi: her satır [ε_i, 1]. Model: σ ≈ E·ε + b
X = np.column_stack([eps, np.ones(n)])
(E_ls, b_ls), *_ = np.linalg.lstsq(X, sigma, rcond=None)   # (XᵀX)⁻¹Xᵀy'yi kararlı biçimde çözer
skl = LinearRegression().fit(eps.reshape(-1, 1), sigma)
tahmin = X @ np.array([E_ls, b_ls])
artik = sigma - tahmin
rmse = np.sqrt(np.mean(artik**2))
r2 = 1 - np.sum(artik**2) / np.sum((sigma - sigma.mean())**2)

# Eğim için standart hata ve %95 güven aralığı (klasik doğrusal regresyon varsayımları)
s2 = np.sum(artik**2) / (n - 2)
se_E = np.sqrt(s2 / np.sum((eps - eps.mean())**2))
t_kritik = stats.t.ppf(0.975, df=n - 2)
print("\n=== 2. Kapalı biçimli çözüm ===")
print(f"NumPy lstsq       : E = {E_ls/1000:.2f} GPa, b = {b_ls:.2f} MPa")
print(f"scikit-learn      : E = {skl.coef_[0]/1000:.2f} GPa, b = {skl.intercept_:.2f} MPa")
print(f"Gerçek (üretilen) : E = {E_GERCEK/1000:.2f} GPa, b = {B_GERCEK:.2f} MPa")
print(f"RMSE = {rmse:.2f} MPa, R² = {r2:.5f}")
print(f"E için %95 güven aralığı: {(E_ls - t_kritik*se_E)/1000:.2f} – {(E_ls + t_kritik*se_E)/1000:.2f} GPa")
assert np.isclose(E_ls, skl.coef_[0]) and np.isclose(b_ls, skl.intercept_)


# %% 3. Gradyan inişi: aynı problemi adım adım çözmek
def gradyan_inisi(x, y, ogrenme_hizi, adim):
    """L(w, b) = ortalama[(w·x + b − y)²] kaybını gradyan inişiyle küçültür."""
    w, b = 0.0, 0.0
    kayiplar, yol = [], [(w, b)]
    for _ in range(adim):
        hata = w * x + b - y                  # ŷ − y
        kayiplar.append(np.mean(hata**2))
        dw = 2 * np.mean(hata * x)            # ∂L/∂w
        db = 2 * np.mean(hata)                # ∂L/∂b
        w -= ogrenme_hizi * dw
        b -= ogrenme_hizi * db
        yol.append((w, b))
    return w, b, np.array(kayiplar), np.array(yol)


print("\n=== 3. Gradyan inişi ===")
# (a) Ham birimler: ε ~ 0.001, σ ~ 100 MPa → kayıp yüzeyi aşırı basık bir vadi
w_a, b_a, L_a, _ = gradyan_inisi(eps, sigma, 0.5, 10_000)
durum = "yakınsadı" if abs(w_a - E_ls) < 0.01 * E_ls else "yakınsamadı"
print(f"(a) Ham birimler, η=0.5, 10000 adım : E = {w_a/1000:8.2f} GPa  ({durum})")

# (b) Birim seçimi: gerinimi ‰ (binde) cinsinden yazınca eğim doğrudan GPa olur
eps_pm = eps * 1e3
w_b, b_b, L_b, yol_b = gradyan_inisi(eps_pm, sigma, 0.5, 10_000)
print(f"(b) Gerinim ‰ cinsinden, η=0.5       : E = {w_b:8.2f} GPa, b = {b_b:.2f} MPa")

# (c) Standartlaştırma: ortalamayı çıkar, standart sapmaya böl
mx, sx, my, sy = eps.mean(), eps.std(), sigma.mean(), sigma.std()
xs, ys = (eps - mx) / sx, (sigma - my) / sy
w_c, b_c, L_c, yol_c = gradyan_inisi(xs, ys, 0.1, 10_000)
E_c = w_c * sy / sx                      # ölçekli eğimi MPa'ya geri çevir
b_cg = my + sy * b_c - E_c * mx
print(f"(c) Standartlaştırılmış, η=0.1        : E = {E_c/1000:8.2f} GPa, b = {b_cg:.2f} MPa")


def ilk_yakinsama(kayip, hedef):
    idx = np.nonzero(kayip <= hedef)[0]
    return str(idx[0]) if idx.size else "hiç (10000 adımda olmadı)"


# Kayıp yüzeyinin eğriliği: Hessyen H = (2/n)·AᵀA, A = [x, 1]
print("Hessyen özdeğerleri (kayıp yüzeyinin en dik ve en yatık yönü):")
for ad, x in [("(a) ham", eps), ("(b) ‰", eps_pm), ("(c) standart", xs)]:
    A = np.column_stack([x, np.ones_like(x)])
    lam = np.linalg.eigvalsh(2 * A.T @ A / len(x))
    print(f"   {ad:13s}: λ_min = {lam[0]:.3g}, λ_max = {lam[1]:.3g}, "
          f"koşul sayısı κ = {lam[1]/lam[0]:.3g}, kararlılık sınırı η < {2/lam[1]:.3g}")

# yakınsama ölçütü: kayıp, en iyi kaybın %0.1 üstüne inince
L_en_iyi = np.mean(artik**2)
L_c_hedef = np.mean(((xs * (E_ls * sx / sy)) + (b_ls - my + E_ls * mx) / sy - ys)**2)
print(f"En iyi MSE (kapalı biçim)            : {L_en_iyi:.3f} MPa²")
print(f"Kaybın en iyinin %0.1 üstüne indiği adım: (a) {ilk_yakinsama(L_a, 1.001*L_en_iyi)}, "
      f"(b) {ilk_yakinsama(L_b, 1.001*L_en_iyi)}, (c) {ilk_yakinsama(L_c, 1.001*L_c_hedef)}")
assert abs(w_b - E_ls / 1000) < 0.01 and abs(E_c - E_ls) < 10

# %% 4. Yanlış model: akma sonrası ölçümleri de doğruya katmak
eps_p = np.linspace(1.9e-3, 6.0e-3, 25)                        # akma sonrası (sentetik)
sigma_p = 360 + 2_000 * (eps_p - 1.75e-3) + rng.normal(0, 3.0, eps_p.size)
eps_t = np.concatenate([eps, eps_p])
sigma_t = np.concatenate([sigma, sigma_p])
E_t, b_t = np.polyfit(eps_t, sigma_t, 1)
artik_t = sigma_t - (E_t * eps_t + b_t)
print("\n=== 4. Yanlış model ===")
print(f"Elastik + plastik tüm noktalara doğru: E = {E_t/1000:.1f} GPa (elastik bölgeden: {E_ls/1000:.1f} GPa)")

# %% 5. Grafikler
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].scatter(eps * 1e3, sigma, s=18, color=SOLUK, alpha=.8, label="Ölçüm (sentetik)")
xx = np.linspace(0, 1.6e-3, 50)
ax[0].plot(xx * 1e3, E_ls * xx + b_ls, color=RENK[0], label=f"En küçük kareler: E = {E_ls/1000:.1f} GPa")
ax[0].plot(xx * 1e3, 210_000 * xx, color=MUREKKEP, ls="--", lw=1.2, label="Nominal 210 GPa (b = 0)")
ax[0].set(xlabel="Gerinim ε (‰)", ylabel="Gerilme σ (MPa)", title="Elastik bölgeye doğru uydurma")
ax[0].legend(loc="upper left")
ax[1].axhline(0, color=MUREKKEP, lw=1)
ax[1].scatter(eps * 1e3, artik, s=18, color=RENK[0])
ax[1].set(xlabel="Gerinim ε (‰)", ylabel="Artık σ − σ̂ (MPa)", title="Artıklar: belirgin bir desen yok")
fig.savefig(KLASOR / "d02_dogrusal_regresyon_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
it = np.arange(1, 10_001)
ax[0].loglog(it, L_a, color=RENK[1], label="(a) ham birimler")
ax[0].loglog(it, L_b, color=RENK[0], label="(b) gerinim ‰")
ax[0].loglog(it, L_c * sy**2, color=RENK[2], label="(c) standartlaştırılmış")
ax[0].axhline(L_en_iyi, color=MUREKKEP, ls=":", lw=1.2, label="En iyi MSE")
ax[0].set(xlabel="Adım", ylabel="MSE (MPa²)", title="Aynı problem, farklı ölçek")
ax[0].legend(loc="center right")
W, B = np.meshgrid(np.linspace(-10, 240, 200), np.linspace(-90, 130, 200))
Z = ((W[..., None] * eps_pm + B[..., None] - sigma)**2).mean(axis=-1)
ax[1].contour(W, B, Z, levels=np.geomspace(Z.min() * 1.05, Z.max(), 16), colors=SOLUK, linewidths=.7)
ax[1].plot(yol_b[:80, 0], yol_b[:80, 1], "-o", ms=3, color=RENK[0], label="Gradyan inişi (b), η=0.5, ilk 80 adım")
ax[1].plot(w_b, b_b, marker="*", ms=13, color=MUREKKEP, ls="none", label="Minimum (en küçük kareler)")
ax[1].set(xlabel="Eğim w = E (GPa)", ylabel="Kesişim b (MPa)", title="Kayıp yüzeyi (gerinim ‰): uzun bir vadi")
ax[1].legend(loc="lower left")
fig.savefig(KLASOR / "d02_dogrusal_regresyon_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].scatter(eps_t * 1e3, sigma_t, s=16, color=SOLUK, label="Ölçüm (sentetik)")
xx = np.linspace(0, 6.2e-3, 50)
ax[0].plot(xx * 1e3, E_t * xx + b_t, color=RENK[1], label=f"Tüm noktalar: E = {E_t/1000:.0f} GPa")
ax[0].plot(xx[:15] * 1e3, (E_ls * xx + b_ls)[:15], color=RENK[0], label=f"Yalnız elastik: E = {E_ls/1000:.0f} GPa")
ax[0].set(xlabel="Gerinim ε (‰)", ylabel="Gerilme σ (MPa)", title="Model biçimi yanlışsa")
ax[0].legend(loc="lower right")
ax[1].axhline(0, color=MUREKKEP, lw=1)
ax[1].scatter(eps_t * 1e3, artik_t, s=16, color=RENK[1])
ax[1].set(xlabel="Gerinim ε (‰)", ylabel="Artık (MPa)", title="Artıklarda sistematik desen")
fig.savefig(KLASOR / "d02_dogrusal_regresyon_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d02_dogrusal_regresyon_1.png, _2.png, _3.png")
