"""Hazırlık 2 — Makine öğrenmesi için matematik.

Kursun geri kalanında kullanılan matematiği küçük sayısal deneylerle doğrular: iç çarpım,
normlar ve uzaklık; matris–vektör çarpımı, koşul sayısı (Hilbert matrisi), özdeğerler ve
kuadratik formlar; gradyan, zincir kuralı ve gradyan kontrolü; Taylor açılımı ve sayısal
türevin hata–adım ilişkisi; varyans, korelasyon, merkezi limit teoremi; en çok olabilirlik
(Gauss olabilirliği ile MSE'nin eşdeğerliği) ve Bayes teoremi.

Veri sentetiktir: bütün örnekler sabit tohumlu rastgele sayılarla ya da elle seçilmiş
değerlerle üretilir (Abrams yasası, düzlem gerilme tensörü, çekme deneyi doğrusu gibi).
Gerçek deney kaydı değildir.

Çalıştır:  python h2_matematik.py
Gerekenler: numpy, scipy, matplotlib  (Python 3.12+)
Süre:      birkaç saniye
Çı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 optimize, stats

# --- 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. Vektörler: iç çarpım, norm ve uzaklık
F = np.array([3.0, 4.0])                                    # kuvvet (kN)
e = np.array([np.cos(np.radians(30)), np.sin(np.radians(30))])  # çubuk ekseni (birim vektör)
eksenel = F @ e                                             # iç çarpım = eksen üzerindeki bileşen
aci = np.degrees(np.arccos(eksenel / (np.linalg.norm(F) * np.linalg.norm(e))))
r = np.array([1.5, -2.0, 0.5, 3.0, -1.0])                   # bir modelin artıkları (MPa)
L1, L2, Linf = np.linalg.norm(r, 1), np.linalg.norm(r), np.linalg.norm(r, np.inf)
n_r = len(r)
print("=== 1. Vektörler ===")
print(f"F = {F} kN, e = {e.round(3)} → F·e = {eksenel:.3f} kN, aradaki açı {aci:.2f}°")
print(f"r = {r} MPa: L1 = {L1:.2f}, L2 = {L2:.3f}, L∞ = {Linf:.2f}")
print(f"MAE = L1/n = {L1 / n_r:.3f}, RMSE = L2/√n = {L2 / np.sqrt(n_r):.3f}, en büyük hata = L∞ = {Linf:.3f} MPa")
assert np.isclose(L2 / np.sqrt(n_r), np.sqrt(np.mean(r**2))) and np.isclose(L1 / n_r, np.mean(np.abs(r)))
# Uzaklık ve ölçek: [çimento (kg/m³), su/bağlayıcı]
a, b, c = np.array([350.0, 0.45]), np.array([360.0, 0.60]), np.array([420.0, 0.46])
olcek = np.array([72.0, 0.12])                              # tablodaki tipik standart sapmalar
for ad, bol in [("ham birim", 1.0), ("standart sapmaya bölünmüş", olcek)]:
    dab, dac = np.linalg.norm((a - b) / bol), np.linalg.norm((a - c) / bol)
    print(f"Uzaklık ({ad}): d(a, b) = {dab:.2f}, d(a, c) = {dac:.2f} → a'ya en yakın: {'b' if dab < dac else 'c'}")

# %% 2. Matrisler: koşul sayısı ve özdeğerler
print("\n=== 2. Matrisler, koşul sayısı, özdeğerler ===")
print("Hilbert sistemi H x = b, gerçek çözüm x = [1, …, 1]:")
print("   n     κ(H)    hata (solve)  hata (inv)  artık (solve)  artık (inv)")
hilbert_tablo = []
for n in [4, 6, 8, 10, 12]:
    i = np.arange(n)
    H = 1.0 / (i[:, None] + i[None, :] + 1)                 # yayınlama ile Hilbert matrisi
    x_gercek = np.ones(n)
    b_h = H @ x_gercek
    x_solve = np.linalg.solve(H, b_h)
    x_inv = np.linalg.inv(H) @ b_h
    hata = [np.linalg.norm(x - x_gercek) / np.linalg.norm(x_gercek) for x in (x_solve, x_inv)]
    artik = [np.linalg.norm(H @ x - b_h) / np.linalg.norm(b_h) for x in (x_solve, x_inv)]
    kappa = np.linalg.cond(H)
    hilbert_tablo.append((n, kappa, *hata))
    print(f"  {n:2d}  {kappa:9.2e}  {hata[0]:10.1e}  {hata[1]:10.1e}  {artik[0]:12.1e}  {artik[1]:11.1e}")
# Monom özelliklerin Gram matrisi Hilbert matrisine yaklaşır: (1/n)Σ x^(i+j) ≈ ∫ x^(i+j) dx = 1/(i+j+1)
x_u = rng.uniform(0.0, 1.0, 100_000)
V = np.vander(x_u, 6, increasing=True)                      # sütunlar: 1, x, x², …, x⁵
G = V.T @ V / len(x_u)
i = np.arange(6)
H6 = 1.0 / (i[:, None] + i[None, :] + 1)
print(f"Özellikler 1, x, …, x⁵ (x ~ U(0, 1)): (XᵀX)/n ile H₆ en büyük bağıl fark "
      f"{np.max(np.abs(G - H6) / H6):.4f}; κ = {np.linalg.cond(G):.2e}")
A = np.array([[80.0, 30.0], [30.0, 20.0]])                  # düzlem gerilme tensörü (MPa)
lam, Q = np.linalg.eigh(A)                                  # simetrik matris: eigh
Q = Q * np.sign(Q[0])                                       # yön işaretini sabitle (keyfi)
yon = np.degrees(np.arctan2(Q[1, 1], Q[0, 1]))              # büyük özdeğerin özvektörü
print(f"A = [[80, 30], [30, 20]] MPa → özdeğerler (asal gerilmeler) {lam.round(2)} MPa, "
      f"büyük asal yön {yon:.2f}°")
B = np.array([[80.0, 30.0], [30.0, -20.0]])                 # σy = −20 MPa: belirsiz matris
lamB, QB = np.linalg.eigh(B)
QB = QB * np.sign(QB[0])
print(f"Q Λ Qᵀ = A: {np.allclose(Q @ np.diag(lam) @ Q.T, A)}, QᵀQ = I: {np.allclose(Q.T @ Q, np.eye(2))}; "
      f"B = [[80, 30], [30, −20]] → özdeğerler {lamB.round(2)}")
assert np.all(lam > 0) and lamB[0] < 0 < lamB[1]

# %% 3. Gradyan, yönlü türev, zincir kuralı ve gradyan kontrolü
nokta = np.array([2.0, 1.0])
grad_f = np.array([2 * nokta[0], 6 * nokta[1]])             # f(x, y) = x² + 3y² → ∇f = [2x, 6y]
u_grad = grad_f / np.linalg.norm(grad_f)
u_dik = np.array([-u_grad[1], u_grad[0]])
min_yon = -nokta / np.linalg.norm(nokta)                    # (2, 1)'den minimuma (0, 0) giden yön
aci_gd = np.degrees(np.arccos((-u_grad) @ min_yon))
print("\n=== 3. Gradyan ve zincir kuralı ===")
print(f"f = x² + 3y², (2, 1) noktasında ∇f = {grad_f}, |∇f| = {np.linalg.norm(grad_f):.3f}")
print(f"Yönlü türev: x yönü {grad_f @ [1, 0]:.3f}, ∇f yönü {grad_f @ u_grad:.3f}, dik yön {abs(grad_f @ u_dik):.3f}; "
      f"−∇f ile minimum yönü arası {aci_gd:.2f}°")

# Tek nöron: ŷ = tanh(X w + b), L = ortalama (ŷ − y)²
X_n = rng.normal(size=(20, 2))
y_n = np.tanh(X_n @ np.array([0.8, -0.5]) + 0.1) + rng.normal(0, 0.05, 20)


def kayip(p):
    return np.mean((np.tanh(X_n @ p[:2] + p[2]) - y_n) ** 2)


def gradyan(p, hatali=False):
    y_hat = np.tanh(X_n @ p[:2] + p[2])
    d = 2 * (y_hat - y_n) / len(y_n)                         # ∂L/∂ŷ
    if not hatali:
        d = d * (1 - y_hat**2)                               # ∂ŷ/∂z = 1 − tanh²(z): zincir kuralı
    return np.append(X_n.T @ d, d.sum())                     # ∂z/∂w = x, ∂z/∂b = 1


def sayisal_gradyan(fonk, p, h=1e-6):
    g = np.zeros_like(p)
    for k in range(len(p)):
        adim = np.zeros_like(p)
        adim[k] = h
        g[k] = (fonk(p + adim) - fonk(p - adim)) / (2 * h)  # merkezi fark
    return g


def bagil_hata(g1, g2):
    return np.linalg.norm(g1 - g2) / (np.linalg.norm(g1) + np.linalg.norm(g2))


p0 = np.array([1.0, 1.0, 0.5])
g_sayisal = sayisal_gradyan(kayip, p0)
h_dogru, h_hatali = bagil_hata(gradyan(p0), g_sayisal), bagil_hata(gradyan(p0, hatali=True), g_sayisal)
print(f"Gradyan kontrolü (tanh nöronu, h = 1e-6): bağıl hata {h_dogru:.1e}; "
      f"(1 − ŷ²) unutulursa {h_hatali:.1e}")
assert h_dogru < 1e-7 < 1e-3 < h_hatali

# %% 4. Taylor açılımı ve sayısal türevin hata–adım ilişkisi
LN7 = np.log(7.0)


def abrams(x):
    return 96.5 * 7.0 ** (-x)                                # 28 günlük dayanım (MPa), x = s/b


x0 = 0.50
f0, f1, f2, f3 = abrams(x0), -LN7 * abrams(x0), LN7**2 * abrams(x0), -(LN7**3) * abrams(x0)
print("\n=== 4. Taylor açılımı ve sayısal türev ===")
print(f"Abrams, s/b = 0.50: f = {f0:.3f}, f′ = {f1:.3f}, f″ = {f2:.3f} MPa")
for x in [0.40, 0.65]:
    t1 = f0 + f1 * (x - x0)
    t2 = t1 + 0.5 * f2 * (x - x0) ** 2
    print(f"s/b = {x:.2f}: gerçek {abrams(x):.3f}, 1. derece {t1:.3f}, 2. derece {t2:.3f} MPa")
h_dizi = np.logspace(-16, -1, 61)
hata_ileri = np.abs((abrams(x0 + h_dizi) - f0) / h_dizi - f1) / abs(f1)
hata_merkez = np.abs((abrams(x0 + h_dizi) - abrams(x0 - h_dizi)) / (2 * h_dizi) - f1) / abs(f1)
secili = [np.argmin(np.abs(np.log10(h_dizi) - k)) for k in (-2, -4, -12)]   # h = 1e-2, 1e-4, 1e-12
print("h = 1e-2, 1e-4, 1e-12 için bağıl hata: ileri " + " / ".join(f"{v:.1e}" for v in hata_ileri[secili])
      + ", merkezi " + " / ".join(f"{v:.1e}" for v in hata_merkez[secili]))
print(f"En küçük hata: ileri fark {hata_ileri.min():.1e} (h ≈ {h_dizi[hata_ileri.argmin()]:.0e}), "
      f"merkezi fark {hata_merkez.min():.1e} (h ≈ {h_dizi[hata_merkez.argmin()]:.0e})")

# %% 5. Ortalama, varyans, korelasyon ve merkezi limit teoremi
sb = rng.uniform(0.35, 0.65, 500)                           # su/bağlayıcı
dayanim = abrams(sb) * rng.lognormal(0.0, 0.07, 500)        # MPa
sicaklik = rng.uniform(5.0, 30.0, 500)                      # bu üreticide dayanımla ilgisiz (°C)
print("\n=== 5. İstatistik ve merkezi limit teoremi ===")
print(f"Dayanım: ortalama {dayanim.mean():.2f} MPa; varyans 1/n = {dayanim.var():.2f}, "
      f"1/(n−1) = {dayanim.var(ddof=1):.2f} MPa²")
R = np.corrcoef(np.vstack([sb, dayanim, sicaklik]))
print(f"cov(s/b, dayanım) = {np.cov(sb, dayanim)[0, 1]:.3f} MPa; korelasyon matrisi [s/b, dayanım, sıcaklık]:\n"
      + np.array2string(R, precision=2, suppress_small=True))
u_e = rng.uniform(-1.0, 1.0, 500)
print(f"u ~ U(−1, 1), v = u²: korelasyon {np.corrcoef(u_e, u_e**2)[0, 1]:.3f} (ilişki tam ama doğrusal değil)")
z_ornek = {}
for k in [1, 2, 5, 30]:
    ort_k = rng.uniform(0.0, 1.0, (100_000, k)).mean(axis=1)  # k düzgün sayının ortalaması
    z = (ort_k - 0.5) / np.sqrt(1 / (12 * k))
    z_ornek[k] = z
    print(f"k = {k:2d}: std {ort_k.std():.4f} (kuram {np.sqrt(1 / (12 * k)):.4f}), basıklık fazlası "
          f"{stats.kurtosis(ort_k):+.3f} (kuram {-1.2 / k:+.3f}), |z| < 1.96: {np.mean(np.abs(z) < 1.96):.3f}")

# %% 6. En çok olabilirlik
kup = rng.normal(38.0, 4.0, 10)                             # 10 küp (MPa), gerçek μ = 38, σ = 4
print("\n=== 6. En çok olabilirlik ===")
print(f"10 küp: μ̂ = x̄ = {kup.mean():.2f} MPa, σ̂ (1/n) = {kup.std():.2f}, s (1/(n−1)) = {kup.std(ddof=1):.2f} MPa")
tekrar = rng.normal(38.0, 4.0, (100_000, 5))                # her tekrarda 5 küp
v_mle, v_s2 = tekrar.var(axis=1), tekrar.var(axis=1, ddof=1)
print(f"5 küplük 100000 tekrar: σ̂² ortalaması {v_mle.mean():.2f} (= {v_mle.mean() / 16:.3f} σ²), "
      f"s² ortalaması {v_s2.mean():.2f} (σ² = 16)")
# Regresyon: Gauss gürültülü doğru için olabilirliği en büyütmek = MSE'yi en küçültmek
eps = np.sort(rng.uniform(0.1, 1.5, 40))                    # gerinim (‰)
sig = 200.0 * eps + 2.0 + rng.normal(0.0, 3.0, 40)          # gerilme (MPa); eğim GPa birimindedir
Xr = np.column_stack([eps, np.ones_like(eps)])
(E_ek, b_ek), *_ = np.linalg.lstsq(Xr, sig, rcond=None)
mse = np.mean((sig - Xr @ [E_ek, b_ek]) ** 2)


def eksi_log_olabilirlik(t):
    E, b0, log_s = t
    s2 = np.exp(2 * log_s)
    return 0.5 * len(sig) * np.log(2 * np.pi * s2) + np.sum((sig - E * eps - b0) ** 2) / (2 * s2)


sonuc = optimize.minimize(eksi_log_olabilirlik, x0=[100.0, 0.0, 0.0], method="BFGS")
E_ml, b_ml, s_ml = sonuc.x[0], sonuc.x[1], np.exp(sonuc.x[2])
print(f"En küçük kareler: E = {E_ek:.3f} GPa, b = {b_ek:.3f} MPa, √MSE = {np.sqrt(mse):.3f} MPa")
print(f"Olabilirliği en büyütme: E = {E_ml:.3f} GPa, b = {b_ml:.3f} MPa, σ̂ = {s_ml:.3f} MPa")
assert np.allclose([E_ml, b_ml, s_ml], [E_ek, b_ek, np.sqrt(mse)], rtol=1e-4, atol=1e-3)

# %% 7. Bayes teoremi: hasar alarmı ve taban oranı
on_olasilik, duyarlilik, yanlis_alarm = 0.02, 0.95, 0.05
sonsal = duyarlilik * on_olasilik / (duyarlilik * on_olasilik + yanlis_alarm * (1 - on_olasilik))
sonsal2 = duyarlilik * sonsal / (duyarlilik * sonsal + yanlis_alarm * (1 - sonsal))
N = 10_000
hasarli = on_olasilik * N
dogru_alarm, sahte_alarm = duyarlilik * hasarli, yanlis_alarm * (N - hasarli)
print("\n=== 7. Bayes: hasar alarmı ===")
print(f"{N} yapı: {hasarli:.0f} hasarlı → {dogru_alarm:.0f} doğru alarm; {N - hasarli:.0f} sağlam → "
      f"{sahte_alarm:.0f} yanlış alarm")
print(f"P(hasar | alarm) = {dogru_alarm:.0f} / {dogru_alarm + sahte_alarm:.0f} = {sonsal:.4f}; "
      f"ikinci bağımsız alarmdan sonra {sonsal2:.4f}")
assert np.isclose(sonsal, dogru_alarm / (dogru_alarm + sahte_alarm))

# %% 8. Grafikler
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
g = np.linspace(-1.5, 1.5, 301)
GX, GY = np.meshgrid(g, g)
for eksen, M, lam_m, Q_m, baslik in [(ax[0], A, lam, Q, "Pozitif tanımlı A: çanak"),
                                     (ax[1], B, lamB, QB, "Belirsiz B: eyer")]:
    Zq = M[0, 0] * GX**2 + 2 * M[0, 1] * GX * GY + M[1, 1] * GY**2   # xᵀ M x
    if np.all(lam_m > 0):
        dolu = eksen.contourf(GX, GY, Zq, levels=12, cmap="Blues")
    else:
        s_max = np.abs(Zq).max()
        dolu = eksen.contourf(GX, GY, Zq, levels=np.linspace(-s_max, s_max, 13), cmap="RdBu_r")
    eksen.contour(GX, GY, Zq, levels=dolu.levels, colors="white", linewidths=0.5)
    for k, renk in enumerate([RENK[1], RENK[0]]):           # sütun 0: küçük λ, sütun 1: büyük λ
        v = Q_m[:, k] * 1.0
        eksen.annotate("", xy=v, xytext=(0, 0), arrowprops=dict(arrowstyle="-|>", color=renk, lw=2.4))
        eksen.text(*(v * 1.12), f"λ = {lam_m[k]:.1f}", color=renk, fontsize=10, fontweight="bold",
                   ha="center", va="center", bbox=dict(boxstyle="round,pad=0.2", fc="white", ec="none", alpha=0.9))
    eksen.set(xlabel="x₁", ylabel="x₂", title=baslik, aspect="equal")
    eksen.grid(False)
    fig.colorbar(dolu, ax=eksen, label="xᵀMx (MPa)", shrink=0.9)
fig.savefig(KLASOR / "h2_matematik_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
xs = np.linspace(0.30, 0.75, 200)
ax[0].plot(xs, abrams(xs), color=MUREKKEP, ls="--", lw=1.5, label="Abrams: 96.5 / 7^(s/b)")
ax[0].plot(xs, f0 + f1 * (xs - x0), color=RENK[0], label="1. derece Taylor")
ax[0].plot(xs, f0 + f1 * (xs - x0) + 0.5 * f2 * (xs - x0) ** 2, color=RENK[1], label="2. derece Taylor")
ax[0].plot(x0, f0, "o", color=MUREKKEP, ms=6)
ax[0].set(xlabel="Su / bağlayıcı oranı (–)", ylabel="28 günlük dayanım (MPa)",
          title="Taylor açılımı, s/b = 0.50 çevresinde")
ax[0].legend(loc="upper right")
EPS = np.finfo(float).eps
ax[1].loglog(h_dizi, hata_ileri, "o-", ms=3, lw=1.2, color=RENK[0], label="İleri fark")
ax[1].loglog(h_dizi, hata_merkez, "o-", ms=3, lw=1.2, color=RENK[1], label="Merkezi fark")
ax[1].loglog(h_dizi, (abs(f2) / 2 * h_dizi + EPS * f0 / h_dizi) / abs(f1), ":", color=RENK[0], lw=1.5,
             label="Kuram: |f″|h/2 + ε|f|/h")
ax[1].loglog(h_dizi, (abs(f3) / 6 * h_dizi**2 + EPS * f0 / h_dizi) / abs(f1), ":", color=RENK[1], lw=1.5,
             label="Kuram: |f‴|h²/6 + ε|f|/h")
ax[1].set(xlabel="Adım h", ylabel="Bağıl türev hatası", title="Sayısal türev: hata–adım ilişkisi",
          ylim=(1e-13, 1e1))
ax[1].legend(loc="lower left", fontsize=8.5)
fig.savefig(KLASOR / "h2_matematik_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
kutu = np.linspace(-4, 4, 61)
for renk, k in zip(RENK[:3], [1, 2, 30]):
    ax[0].hist(z_ornek[k], bins=kutu, density=True, histtype="step", lw=1.8, color=renk,
               label=f"k = {k}")
zz = np.linspace(-4, 4, 200)
ax[0].plot(zz, np.exp(-zz**2 / 2) / np.sqrt(2 * np.pi), color=MUREKKEP, ls="--", lw=1.4, label="Standart normal")
ax[0].set(xlabel="k düzgün sayının standartlaştırılmış ortalaması z", ylabel="Olasılık yoğunluğu",
          title="Merkezi limit teoremi", ylim=(0, 0.52))
ax[0].legend(loc="upper left", ncol=2)
kutu2 = np.linspace(0, 60, 61)
ax[1].hist(v_mle, bins=kutu2, density=True, histtype="step", lw=1.8, color=RENK[0], label="σ̂² (1/n), en çok olabilirlik")
ax[1].hist(v_s2, bins=kutu2, density=True, histtype="step", lw=1.8, color=RENK[1], label="s² (1/(n−1))")
ax[1].axvline(v_mle.mean(), color=RENK[0], lw=1.2, label=f"σ̂² ortalaması = {v_mle.mean():.2f}")
ax[1].axvline(v_s2.mean(), color=RENK[1], lw=1.2, label=f"s² ortalaması = {v_s2.mean():.2f}")
ax[1].axvline(16.0, color=MUREKKEP, ls="--", lw=1.4, label="Gerçek σ² = 16 MPa²")
ax[1].set(xlabel="Varyans tahmini (MPa²)", ylabel="Olasılık yoğunluğu",
          title="5 küplük örneklemde varyans tahmini")
ax[1].legend(loc="upper right", fontsize=8.5)
fig.savefig(KLASOR / "h2_matematik_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: h2_matematik_1.png, _2.png, _3.png")
