"""Ders 11 — Yapay sinir ağları: sıfırdan geri yayılım.

İki gizli katmanlı bir sinir ağını yalnızca NumPy ile kuruyoruz: ileri yayılım, geri yayılım,
merkezi farkla gradyan kontrolü, başlatma ve mini-yığın gradyan inişi (SGD). İki örnek var:
  1) Regresyon: bir alüminyum alaşımının Ramberg–Osgood eğrisi ε = σ/E + 0,002·(σ/f0,2)^n
     verildiğinde ters ilişki σ(ε)'yi gürültülü örneklerden öğrenmek; polinomla karşılaştırmak.
  2) Sınıflandırma: iç içe iki sarmal; gizli katman genişliğinin karar sınırına etkisi.
Veriler sentetiktir. E = 70 GPa, f0,2 = 160 MPa, n = 20 örnek amaçlı seçilmiş değerlerdir;
belirli bir alaşımın tasarım değerleri değildir. Ölçüm gürültüsü normal dağılımla eklenir.

Çalıştır:  python d11_sinir_agi_sifirdan.py
Gerekenler: numpy, matplotlib  (Python 3.12+)
Süre:      yaklaşık 10–40 s (bilgisayara göre)
Çıktılar:  terminale sayılar, aynı klasöre üç PNG grafiği
"""
import math
from pathlib import Path

import numpy as np
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap

# --- 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. Aktivasyon fonksiyonları ve türevleri
def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))


def gelu(z):
    """GELU(z) = z·Φ(z); Φ standart normal dağılım fonksiyonu."""
    Phi = 0.5 * (1.0 + np.vectorize(math.erf)(z / math.sqrt(2.0)))
    return z * Phi


AKT = {  # ad: (φ(z), φ'(z))
    "tanh": (np.tanh, lambda z: 1.0 - np.tanh(z) ** 2),
    "relu": (lambda z: np.maximum(z, 0.0), lambda z: (z > 0).astype(float)),
    "sigmoid": (sigmoid, lambda z: sigmoid(z) * (1.0 - sigmoid(z))),
}
print("=== 1. Aktivasyon fonksiyonları ===")
print(f"En büyük türevler: sigmoid'(0) = {AKT['sigmoid'][1](0.0):.2f}, tanh'(0) = {AKT['tanh'][1](0.0):.2f}, "
      f"ReLU'(z>0) = 1")
print(f"10 sigmoid katmanında aktivasyon türevlerinden gelen çarpan en fazla 0.25^10 = {0.25**10:.1e}")


# %% 2. İki gizli katmanlı ağ: ileri ve geri yayılım (satır = örnek)
def baslat(boyutlar, yontem, rng):
    """boyutlar = [p, h1, h2, 1]. Xavier: Var(w) = 2/(n_g + n_ç) (tanh); He: Var(w) = 2/n_g (ReLU)."""
    P = {}
    for l, (n_g, n_c) in enumerate(zip(boyutlar[:-1], boyutlar[1:]), start=1):
        std = np.sqrt(2.0 / (n_g + n_c)) if yontem == "xavier" else np.sqrt(2.0 / n_g)
        P[f"W{l}"] = rng.normal(0.0, std, (n_g, n_c))
        P[f"b{l}"] = np.zeros(n_c)
    return P


def ileri(P, X, akt):
    f = AKT[akt][0]
    Z1 = X @ P["W1"] + P["b1"]          # (n, h1)
    A1 = f(Z1)
    Z2 = A1 @ P["W2"] + P["b2"]         # (n, h2)
    A2 = f(Z2)
    Z3 = A2 @ P["W3"] + P["b3"]         # (n, 1): regresyonda ŷ, sınıflandırmada logit
    return Z3, (X, Z1, A1, Z2, A2)


def kayip_ve_delta(Z3, Y, tur):
    """Kayıp ve δ3 = ∂L/∂Z3. MSE: L = (1/n)Σ(ŷ−y)²; BCE: L = (1/n)Σ[log(1+e^z) − y·z]."""
    n = len(Y)
    if tur == "mse":
        return np.mean((Z3 - Y) ** 2), 2.0 * (Z3 - Y) / n
    return np.mean(np.logaddexp(0.0, Z3) - Y * Z3), (sigmoid(Z3) - Y) / n


def geri(P, onbellek, d3, akt):
    """Zincir kuralı, matris biçiminde: dW = Aᵀδ, db = δ'nın sütun toplamı, δ_önceki = (δWᵀ)⊙φ'(Z)."""
    X, Z1, A1, Z2, A2 = onbellek
    fp = AKT[akt][1]
    g = {"W3": A2.T @ d3, "b3": d3.sum(axis=0)}
    d2 = (d3 @ P["W3"].T) * fp(Z2)
    g["W2"], g["b2"] = A1.T @ d2, d2.sum(axis=0)
    d1 = (d2 @ P["W2"].T) * fp(Z1)
    g["W1"], g["b1"] = X.T @ d1, d1.sum(axis=0)
    return g


def egit(P, X, Y, akt, tur, ogrenme_hizi, yigin, donem, rng):
    """Mini-yığın SGD; öğrenme hızı kosinüs eğrisiyle η0'dan sıfıra iner."""
    n = len(X)
    for d in range(donem):
        eta = ogrenme_hizi * 0.5 * (1.0 + np.cos(np.pi * d / donem))
        sira = rng.permutation(n)                 # her dönem karıştır
        for i in range(0, n, yigin):
            j = sira[i:i + yigin]
            Z3, onb = ileri(P, X[j], akt)
            _, d3 = kayip_ve_delta(Z3, Y[j], tur)
            g = geri(P, onb, d3, akt)
            for k in P:
                P[k] -= eta * g[k]
    return P


def parametre_sayisi(P):
    return sum(v.size for v in P.values())


# %% 3. Gradyan kontrolü: analitik gradyan ile merkezi farkı karşılaştır
def sayisal_gradyan(P, X, Y, akt, tur, h=1e-6):
    G = {}
    for k, A in P.items():
        G[k] = np.zeros_like(A)
        for idx in np.ndindex(A.shape):
            eski = A[idx]
            A[idx] = eski + h
            L_arti = kayip_ve_delta(ileri(P, X, akt)[0], Y, tur)[0]
            A[idx] = eski - h
            L_eksi = kayip_ve_delta(ileri(P, X, akt)[0], Y, tur)[0]
            A[idx] = eski
            G[k][idx] = (L_arti - L_eksi) / (2 * h)
    return G


def bagil_hata(a, b):
    return np.linalg.norm(a - b) / max(np.linalg.norm(a) + np.linalg.norm(b), 1e-300)


print("\n=== 2. Gradyan kontrolü (merkezi fark, h = 1e-6, float64) ===")
Xk = rng.normal(size=(8, 3))
for akt, tur in [("tanh", "mse"), ("tanh", "bce"), ("relu", "mse")]:
    Yk = rng.normal(size=(8, 1)) if tur == "mse" else rng.integers(0, 2, (8, 1)).astype(float)
    Pk = baslat([3, 5, 4, 1], "xavier", rng)
    Z3, onb = ileri(Pk, Xk, akt)
    g_ana = geri(Pk, onb, kayip_ve_delta(Z3, Yk, tur)[1], akt)
    g_say = sayisal_gradyan(Pk, Xk, Yk, akt, tur)
    hatalar = {k: bagil_hata(g_ana[k], g_say[k]) for k in Pk}
    print(f"{akt:4s} + {tur.upper():3s}: " + ", ".join(f"{k} {v:.1e}" for k, v in hatalar.items()))
    if akt == "relu":   # ReLU'nun z = 0'da kırığı var; orada türev tanımsız
        kirik = int(np.sum(np.abs(onb[1]) < 1e-6) + np.sum(np.abs(onb[3]) < 1e-6))
        print(f"   ReLU: kırık noktasında (|z| < h) duran ön-aktivasyon sayısı = {kirik}")
        assert kirik > 0 or max(hatalar.values()) < 1e-7
    else:
        assert max(hatalar.values()) < 1e-7
        if tur == "mse":
            Pt, Xt, Yt, gt = Pk, Xk, Yk, g_ana["W1"]
print("h'nin etkisi (tanh + MSE, W1): " + ", ".join(
    f"h = {h:.0e}: {bagil_hata(gt, sayisal_gradyan(Pt, Xt, Yt, 'tanh', 'mse', h)['W1']):.1e}"
    for h in [1e-2, 1e-4, 1e-6, 1e-8]))

# %% 4. Başlatma: simetri bozma ve katmanlar boyunca ölçek
print("\n=== 3. Başlatma ===")
Xs = rng.uniform(-1, 1, (64, 1))
Ys = np.sin(3 * Xs)
donem_s, yigin_s = 50, 16
adim_s = donem_s * -(-len(Xs) // yigin_s)                  # dönem × dönem başına yığın sayısı
for ad, P0 in [("hepsi 0.5", {k: (np.full_like(v, 0.5) if k[0] == "W" else v.copy())
                              for k, v in baslat([1, 8, 8, 1], "xavier", rng).items()}),
               ("Xavier", baslat([1, 8, 8, 1], "xavier", rng))]:
    P0 = egit(P0, Xs, Ys, "tanh", "mse", 0.1, yigin_s, donem_s, rng)
    fark = np.abs(P0["W1"] - P0["W1"][:, :1]).max()       # gizli birimler birbirinden ne kadar farklı?
    print(f"Başlangıç {ad:9s}: {adim_s} adım sonra 1. katman birimleri arasındaki en büyük fark = {fark:.2e}")

Xd = rng.normal(size=(500, 256))
olcek = {}
for ad, std in [("N(0, 0.01²)", 0.01), ("Xavier", np.sqrt(2 / 512)), ("He", np.sqrt(2 / 256))]:
    A = Xd
    for _ in range(20):                                   # 20 gizli katman, ReLU
        Z = A @ rng.normal(0, std, (256, 256))
        A = np.maximum(Z, 0)
    olcek[ad] = Z.std()
print("20 katmanlı ReLU ağında son katman ön-aktivasyonunun std'si (girdi std = 1): "
      + ", ".join(f"{k}: {v:.1e}" for k, v in olcek.items()))

# %% 5. Örnek 1 — Ramberg–Osgood: σ(ε) regresyonu
E_MOD, F02, N_RO = 70_000.0, 160.0, 20.0   # MPa, MPa, -  (örnek değerler)
EPS_UST = 0.015                            # eğitim verisinin gerinim üst sınırı (%1,5)
GURULTU = 2.0                              # MPa, gerilme ölçüm gürültüsünün std'si


def eps_ro(s):
    return s / E_MOD + 0.002 * (s / F02) ** N_RO


def sigma_ro(eps, iterasyon=60):
    """ε(σ) monoton artan → σ(ε)'yı ikiye bölme (bisection) ile bul; kapalı biçimi yok."""
    alt, ust = np.zeros_like(eps), np.full_like(eps, 2 * F02)
    for _ in range(iterasyon):
        orta = 0.5 * (alt + ust)
        buyuk = eps_ro(orta) > eps
        ust, alt = np.where(buyuk, orta, ust), np.where(buyuk, alt, orta)
    return 0.5 * (alt + ust)


n_eg, n_dog = 200, 60
eps = rng.uniform(0, EPS_UST, n_eg + n_dog)
sig = sigma_ro(eps) + rng.normal(0, GURULTU, eps.size)
eg, dog = np.arange(n_eg), np.arange(n_eg, n_eg + n_dog)
izgara = np.linspace(0, EPS_UST, 1001)
sig_izgara = sigma_ro(izgara)
assert np.allclose(eps_ro(sig_izgara), izgara, atol=1e-12)

# standartlaştırma (yalnız eğitim verisinin istatistikleriyle)
mx, sx = eps[eg].mean(), eps[eg].std()
my, sy = sig[eg].mean(), sig[eg].std()
X = ((eps - mx) / sx)[:, None]
Y = ((sig - my) / sy)[:, None]


def ag_tahmin(P, e):
    return ileri(P, ((e - mx) / sx)[:, None], "tanh")[0][:, 0] * sy + my


P_ro = baslat([1, 16, 16, 1], "xavier", rng)
P_ro = egit(P_ro, X[eg], Y[eg], "tanh", "mse", 0.2, 16, 2000, rng)


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


ag = {"eğitim": rmse(ag_tahmin(P_ro, eps[eg]), sig[eg]), "doğrulama": rmse(ag_tahmin(P_ro, eps[dog]), sig[dog]),
      "gerçek eğri": rmse(ag_tahmin(P_ro, izgara), sig_izgara)}
hata_ag = ag_tahmin(P_ro, izgara) - sig_izgara

# polinom regresyonu: derece doğrulama RMSE'siyle seçilir (Polynomial.fit girdiyi [-1, 1]'e ölçekler)
pol_sonuc = []
for derece in range(1, 21):
    pol = np.polynomial.Polynomial.fit(eps[eg], sig[eg], derece)
    pol_sonuc.append((rmse(pol(eps[dog]), sig[dog]), derece, pol))
_, d_en_iyi, pol = min(pol_sonuc, key=lambda s: s[0])
pk = {"eğitim": rmse(pol(eps[eg]), sig[eg]), "doğrulama": rmse(pol(eps[dog]), sig[dog]),
      "gerçek eğri": rmse(pol(izgara), sig_izgara)}
hata_pol = pol(izgara) - sig_izgara

print("\n=== 4. Örnek 1: Ramberg–Osgood eğrisini öğrenmek ===")
print(f"Veri: {n_eg} eğitim + {n_dog} doğrulama ölçümü, ε ∈ [0, {EPS_UST}], gürültü std = {GURULTU} MPa; "
      f"gerçek σ aralığı 0–{sig_izgara.max():.1f} MPa")
print(f"Eğitim ölçümlerine eklenen gürültünün gerçekleşen RMS'si: {rmse(sig[eg], sigma_ro(eps[eg])):.2f} MPa")
print(f"Ağ 1-16-16-1 (tanh, {parametre_sayisi(P_ro)} parametre), SGD: yığın 16, η0 = 0.2, 2000 dönem")
for ad, s in [("Sinir ağı", ag), (f"Polinom (derece {d_en_iyi})", pk)]:
    print(f"{ad:20s}: RMSE eğitim {s['eğitim']:.2f}, doğrulama {s['doğrulama']:.2f}, "
          f"gerçek eğriye göre {s['gerçek eğri']:.2f} MPa")
for ad, h in [("Sinir ağı", hata_ag), ("Polinom", hata_pol)]:
    i = np.argmax(np.abs(h))
    print(f"{ad:20s}: gerçek eğriden en büyük sapma {h[i]:+.2f} MPa (ε = %{izgara[i]*100:.2f})")
buyuk_hata = izgara[np.abs(hata_ag) > 1.0]
print(f"Sinir ağının hatası 1 MPa'yı yalnızca ε < %{buyuk_hata.max()*100:.2f} bölgesinde aşıyor "
      f"({len(buyuk_hata)} / {len(izgara)} ızgara noktası)")
dis = np.array([0.0175, 0.02])
print("Aralık dışı ε = %1.75 ve %2: gerçek " + ", ".join(f"{v:.1f}" for v in sigma_ro(dis))
      + " | ağ " + ", ".join(f"{v:.1f}" for v in ag_tahmin(P_ro, dis))
      + " | polinom " + ", ".join(f"{v:.1e}" for v in pol(dis)) + " MPa")
assert ag["gerçek eğri"] < GURULTU

# %% 6. Örnek 2 — Sarmal: gizli katman genişliğinin etkisi
def sarmal(n, rng, gurultu=0.08, tur=1.5):
    t = np.sqrt(rng.uniform(0.02, 1.0, n))            # yarıçap; merkezde seyrek
    k = rng.integers(0, 2, n)                         # sınıf
    aci = 2 * np.pi * tur * t + np.pi * k             # iki kol yarım tur kaydırılmış
    X = np.column_stack([t * np.cos(aci), t * np.sin(aci)]) + rng.normal(0, gurultu, (n, 2))
    return X, k.astype(float)[:, None]


Xs_eg, ys_eg = sarmal(400, rng)
Xs_te, ys_te = sarmal(400, rng)
m_s, s_s = Xs_eg.mean(axis=0), Xs_eg.std(axis=0)        # girdileri standartlaştır (eğitim istatistiği)
print("\n=== 5. Örnek 2: sarmal, iki gizli katman, tanh ===")
sarmal_ag = {}
for h in [2, 4, 8, 32]:
    P = baslat([2, h, h, 1], "xavier", rng)
    P = egit(P, (Xs_eg - m_s) / s_s, ys_eg, "tanh", "bce", 0.3, 32, 500, rng)
    z_eg, z_te = ileri(P, (Xs_eg - m_s) / s_s, "tanh")[0], ileri(P, (Xs_te - m_s) / s_s, "tanh")[0]
    d_eg, d_te = np.mean((z_eg > 0) == ys_eg), np.mean((z_te > 0) == ys_te)
    L_te = kayip_ve_delta(z_te, ys_te, "bce")[0]
    sarmal_ag[h] = (P, d_eg, d_te)
    print(f"h = {h:2d} ({parametre_sayisi(P):4d} parametre): "
          f"doğruluk eğitim %{d_eg*100:.1f}, test %{d_te*100:.1f}; test çapraz entropisi {L_te:.3f}")

# %% 7. Grafikler
z = np.linspace(-4, 4, 401)
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
egriler = [("sigmoid", sigmoid(z), AKT["sigmoid"][1](z)), ("tanh", np.tanh(z), AKT["tanh"][1](z)),
           ("ReLU", np.maximum(z, 0), (z > 0).astype(float))]
g_z = gelu(z)
g_t = np.gradient(g_z, z)                              # GELU türevi (yalnız çizim için sayısal)
for i, (ad, f, fp) in enumerate(egriler):
    ax[0].plot(z, f, color=RENK[i], label=ad)
    ax[1].plot(z, fp, color=RENK[i], label=ad)
ax[0].plot(z, g_z, color=RENK[3], ls="--", lw=1.5, label="GELU")
ax[1].plot(z, g_t, color=RENK[3], ls="--", lw=1.5, label="GELU")
ax[0].set(xlabel="z", ylabel="φ(z)", title="Aktivasyon fonksiyonları", ylim=(-1.3, 4.1))
ax[1].set(xlabel="z", ylabel="φ′(z)", title="Türevleri: gradyan bu katsayılarla çarpılır", ylim=(-0.15, 1.2))
ax[0].legend(loc="upper left")
ax[1].legend(loc="upper left")
fig.savefig(KLASOR / "d11_sinir_agi_sifirdan_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
genis = np.linspace(0, 0.02, 801)
ax[0].axvspan(EPS_UST * 100, 2.0, color="#f1f0eb", lw=0, label="Eğitim aralığı dışı")
ax[0].scatter(eps[eg] * 100, sig[eg], s=10, color=SOLUK, alpha=.7, label="Ölçüm (sentetik)")
ax[0].plot(genis * 100, sigma_ro(genis), color=MUREKKEP, ls="--", lw=1.2, label="Gerçek Ramberg–Osgood")
ax[0].plot(genis * 100, ag_tahmin(P_ro, genis), color=RENK[0], label="Sinir ağı 1-16-16-1")
ax[0].plot(genis * 100, pol(genis), color=RENK[1], ls=":", label=f"Polinom, derece {d_en_iyi}")
ax[0].set(xlabel="Gerinim ε (%)", ylabel="Gerilme σ (MPa)", title="σ(ε) eğrisini öğrenmek", ylim=(-10, 230))
ax[0].legend(loc="lower right")
ax[1].axhspan(-GURULTU, GURULTU, color="#f1f0eb", lw=0, label="± gürültü std (2 MPa)")
ax[1].axhline(0, color=MUREKKEP, lw=1)
ax[1].plot(izgara * 100, hata_ag, color=RENK[0], label=f"Sinir ağı (RMSE {ag['gerçek eğri']:.2f} MPa)")
ax[1].plot(izgara * 100, hata_pol, color=RENK[1], ls=":", label=f"Polinom (RMSE {pk['gerçek eğri']:.2f} MPa)")
ax[1].set(xlabel="Gerinim ε (%)", ylabel="Tahmin − gerçek σ (MPa)",
          title="Gerçek eğriden sapma (eğitim aralığı)")
ax[1].legend(loc="upper right")
fig.savefig(KLASOR / "d11_sinir_agi_sifirdan_2.png", dpi=160)
plt.close(fig)

renk_haritasi = LinearSegmentedColormap.from_list("mavi_turuncu", [RENK[0], "#ffffff", RENK[1]])
g1, g2 = np.meshgrid(np.linspace(-1.35, 1.35, 250), np.linspace(-1.35, 1.35, 250))
G = np.column_stack([g1.ravel(), g2.ravel()])
fig, axs = plt.subplots(2, 2, figsize=(8.4, 7.6), layout="constrained")   # kare paneller
for a, (h, (P, d_eg, d_te)) in zip(axs.ravel(), sarmal_ag.items()):
    p = sigmoid(ileri(P, (G - m_s) / s_s, "tanh")[0][:, 0]).reshape(g1.shape)
    a.contourf(g1, g2, p, levels=np.linspace(0, 1, 6), cmap=renk_haritasi, alpha=.55)
    a.grid(False)
    a.contour(g1, g2, p, levels=[0.5], colors=MUREKKEP, linewidths=1.3)
    sinif = ys_eg[:, 0] == 1
    a.scatter(*Xs_eg[~sinif].T, s=8, color=RENK[0], linewidths=0, label="Sınıf 0 (eğitim)")
    a.scatter(*Xs_eg[sinif].T, s=8, color=RENK[1], linewidths=0, label="Sınıf 1 (eğitim)")
    a.set(title=f"h = {h} · eğitim %{d_eg*100:.1f} · test %{d_te*100:.1f}", xlabel="x₁", ylabel="x₂",
          aspect="equal", xlim=(-1.35, 1.35), ylim=(-1.35, 1.35))
axs[0, 0].legend(loc="lower left", fontsize=8.5)
fig.savefig(KLASOR / "d11_sinir_agi_sifirdan_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d11_sinir_agi_sifirdan_1.png, _2.png, _3.png")
