"""Ders 06 — k-en yakın komşu ve destek vektör makineleri.

Kumlu zeminde sıvılaşma tetiklenmesini iki özellikten sınıflandırıyoruz: temiz kuma eşdeğer
düzeltilmiş SPT darbe sayısı (N1)60cs ve deprem yükü oranı CSR (M = 7.5 ve σ'v = 1 atm koşullarına
ölçekli).

Veri sentetiktir; gerçek bir vaka geçmişi veritabanı değildir. Sınır, Idriss ve Boulanger (2008)
SPT tabanlı ilişkisinden gelir:
    CRR = exp(N/14.1 + (N/126)² − (N/23.6)³ + (N/25.4)⁴ − 2.8),   N = (N1)60cs
Bir "vaka" CSR > CRR·ε ise sıvılaşmış sayılır; ε, ortancası 1 ve logaritmik standart sapması
0.15 olan lognormal bir saçılımdır (eğitim amaçlı varsayım). Mühendislikte yayımlanmış CRR
eğrileri kullanılır; buradaki modeller yöntemleri öğrenmek içindir.

Çalıştır:  python d06_knn_svm.py
Gerekenler: numpy, scikit-learn, matplotlib (Pillow onunla gelir)  (Python 3.12+)
Çıktılar:  terminale sayılar, aynı klasöre üç PNG grafiği
"""
import io
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.lines import Line2D
from PIL import Image
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV, StratifiedKFold, train_test_split, validation_curve
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

# --- 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


def kaydet(fig, ad):
    """PNG'yi 256 renkli paletle kaydeder: düz renkli grafikte fark görünmez, dosya yaklaşık 3 kat küçülür."""
    tampon = io.BytesIO()
    fig.savefig(tampon, format="png", dpi=160)
    Image.open(tampon).convert("RGB").quantize(256, dither=Image.Dither.NONE).save(KLASOR / ad, optimize=True)
    plt.close(fig)


def crr(N):
    """Idriss–Boulanger (2008) SPT tabanlı CRR (M = 7.5, σ'v = 1 atm); N = (N1)60cs."""
    return np.exp(N / 14.1 + (N / 126) ** 2 - (N / 23.6) ** 3 + (N / 25.4) ** 4 - 2.8)


# %% 1. Veri: sentetik vaka geçmişleri
rng = np.random.default_rng(42)
n = 500
N1 = rng.uniform(5, 35, n)                     # (N1)60cs, darbe/30 cm
CSR = rng.uniform(0.05, 0.60, n)               # deprem yükü oranı
eps = rng.lognormal(0.0, 0.15, n)              # sınırdaki saçılım (varsayım)
y = (CSR > crr(N1) * eps).astype(int)          # 1 = sıvılaştı, 0 = sıvılaşmadı
X = np.column_stack([N1, CSR])
X_eg, X_te, y_eg, y_te = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)
olcek = StandardScaler().fit(X_eg)             # ortalama ve std yalnız eğitim verisinden
Z_eg, Z_te = olcek.transform(X_eg), olcek.transform(X_te)
print("=== 1. Veri (sentetik vaka geçmişleri) ===")
print(f"Örnek: {n} (eğitim {len(y_eg)}, test {len(y_te)}), sıvılaştı oranı: {y.mean():.3f}")
print("CRR kontrolü: " + ", ".join(f"N={v} → {crr(v):.3f}" for v in (10, 20, 30)))
print(f"Eğitim kümesi: ortalama ({olcek.mean_[0]:.2f}, {olcek.mean_[1]:.3f}), "
      f"std ((N1)60cs = {olcek.scale_[0]:.2f}, CSR = {olcek.scale_[1]:.3f})")


# %% 2. k-NN: sıfırdan ve scikit-learn; ölçeklemenin etkisi
def knn_tahmin(X_eg, y_eg, X_yeni, k):
    """Öklid uzaklığına göre en yakın k komşunun çoğunluk oyu (ikili sınıf, tek k)."""
    d2 = ((X_yeni[:, None, :] - X_eg[None, :, :]) ** 2).sum(axis=2)   # (m, n) kare uzaklık
    komsu = np.argsort(d2, axis=1)[:, :k]                              # en yakın k komşu
    return (y_eg[komsu].mean(axis=1) > 0.5).astype(int)


K = 15
t_sifirdan = knn_tahmin(Z_eg, y_eg, Z_te, K)
knn_s = KNeighborsClassifier(n_neighbors=K).fit(Z_eg, y_eg)
knn_ham = KNeighborsClassifier(n_neighbors=K).fit(X_eg, y_eg)
fark2 = (X_eg[:, None, :] - X_eg[None, :, :]) ** 2                    # özellik başına kare farklar
pay_N = fark2[..., 0].sum() / fark2.sum()
print(f"\n=== 2. k-NN (k = {K}) ===")
print(f"Sıfırdan k-NN ile scikit-learn aynı tahmin: {np.sum(t_sifirdan == knn_s.predict(Z_te))}/{len(y_te)}")
print(f"Ham birimler   : test doğruluğu {knn_ham.score(X_te, y_te):.3f} "
      f"(kare uzaklıkta (N1)60cs payı %{100 * pay_N:.2f})")
print(f"Standartlaştırılmış: test doğruluğu {knn_s.score(Z_te, y_te):.3f}")
assert np.array_equal(t_sifirdan, knn_s.predict(Z_te))

# %% 3. k seçimi: doğrulama eğrisi (5 katlı çapraz doğrulama)
kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
k_listesi = np.array([1, 3, 5, 9, 15, 21, 31, 45, 61, 91, 121, 181])
boru = make_pipeline(StandardScaler(), KNeighborsClassifier())
egt_skor, cv_skor = validation_curve(boru, X_eg, y_eg, param_name="kneighborsclassifier__n_neighbors",
                                     param_range=k_listesi, cv=kfold)
egt_ort, cv_ort = egt_skor.mean(axis=1), cv_skor.mean(axis=1)
# Eşitlikte daha büyük k (daha düzgün sınır, daha basit model) seçilir
k_iyi = int(k_listesi[np.isclose(cv_ort, cv_ort.max())].max())
knn_iyi = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=k_iyi)).fit(X_eg, y_eg)
print("\n=== 3. k seçimi (5 katlı CV, standartlaştırılmış) ===")
print("   k   eğitim     CV")
for k, a, b in zip(k_listesi, egt_ort, cv_ort):
    if k in (1, 3, 5, 15, 31, 61, 121, 181) or k == k_iyi:
        print(f"{k:4d}   {a:.3f}   {b:.3f}" + ("   ← seçilen" if k == k_iyi else ""))
uc_k = {k: make_pipeline(StandardScaler(), KNeighborsClassifier(k)).fit(X_eg, y_eg).score(X_te, y_te)
        for k in (1, 181)}
print(f"Seçilen k = {k_iyi}: test doğruluğu {knn_iyi.score(X_te, y_te):.3f}; karşılaştırma için test: "
      + ", ".join(f"k = {k} → {d:.3f}" for k, d in uc_k.items()))

# %% 4. Boyut laneti: yüksek boyutta en yakın ve en uzak komşu birbirine yaklaşır
boyutlar = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000]
oranlar = []
for d in boyutlar:
    P = rng.uniform(size=(500, d))             # birim hiperküpte 500 nokta
    Q = rng.uniform(size=(50, d))              # 50 sorgu noktası
    D = np.sqrt(np.maximum((Q**2).sum(1)[:, None] + (P**2).sum(1)[None, :] - 2 * Q @ P.T, 0))
    oranlar.append(np.mean(D.min(axis=1) / D.max(axis=1)))
print("\n=== 4. Boyut laneti (500 düzgün nokta, 50 sorgu) ===")
print("En yakın / en uzak uzaklık oranı: " +
      ", ".join(f"d={d}: {r:.3f}" for d, r in zip(boyutlar, oranlar) if d in (1, 2, 10, 100, 1000)))
print("Verinin %1'ini içeren alt küpün kenarı: " +
      ", ".join(f"d={d}: {0.01 ** (1 / d):.2f}" for d in (1, 2, 10, 100)))

# %% 5. SVM (RBF çekirdek): ızgara araması, destek vektörleri, karar fonksiyonu
C_list = np.logspace(-1, 3, 9)
g_list = np.logspace(-2, 2, 9)
# Ölçekleyici boru hattının içinde: her CV katında yalnız o katın eğitim kısmından öğrenilir
arama = GridSearchCV(make_pipeline(StandardScaler(), SVC(kernel="rbf")),
                     {"svc__C": C_list, "svc__gamma": g_list}, cv=kfold).fit(X_eg, y_eg)
svm_boru = arama.best_estimator_               # bütün eğitim verisiyle yeniden eğitilmiş en iyi boru hattı
svm = svm_boru[-1]                             # içindeki SVC
C_iyi, g_iyi = arama.best_params_["svc__C"], arama.best_params_["svc__gamma"]
izgara_cv = arama.cv_results_["mean_test_score"].reshape(len(C_list), len(g_list))  # satır: C
alfa_y = svm.dual_coef_[0]                     # αᵢ·yᵢ (yalnız destek vektörleri için)
Zb_te = svm_boru[0].transform(X_te)          # boru hattının ölçekleyicisiyle ölçeklenmiş test verisi
K_te = np.exp(-g_iyi * ((Zb_te[:, None, :] - svm.support_vectors_[None, :, :]) ** 2).sum(axis=2))
f_elle = K_te @ alfa_y + svm.intercept_[0]     # f(x) = Σ αᵢyᵢ k(xᵢ, x) + b
serbest = np.abs(alfa_y) < C_iyi - 1e-8        # 0 < α < C: tam pay üzerindeki noktalar
y_pm = np.where(y_eg[svm.support_] == 1, 1, -1)
marj = y_pm * svm.decision_function(svm.support_vectors_)
asiri = SVC(kernel="rbf", C=1000, gamma=100).fit(Z_eg, y_eg)
az = SVC(kernel="rbf", C=0.1, gamma=100).fit(Z_eg, y_eg)    # ızgaranın az uyum köşesi
print("\n=== 5. SVM (RBF çekirdek) ===")
print(f"Izgara araması ({len(C_list)} × {len(g_list)} aday, 5 katlı CV): C = {C_iyi:.3g}, γ = {g_iyi:.3g}, "
      f"CV doğruluğu {arama.best_score_:.3f}")
koseler = ((0, 0), (0, -1), (-1, 0), (-1, -1))
print("Izgaranın köşeleri (CV): " + ", ".join(
    f"C={C_list[a]:g}/γ={g_list[b]:g}: {izgara_cv[a, b]:.3f}" for a, b in koseler))
esit = np.argwhere(np.isclose(izgara_cv, izgara_cv.max()))       # en iyiyle aynı CV doğruluğu
print("CV'si en iyiye eşit: " + ", ".join(f"C={C_list[a]:.3g}/γ={g_list[b]:.3g}" for a, b in esit))
print(f"Test doğruluğu: {svm_boru.score(X_te, y_te):.3f}")
print(f"Destek vektörü: {len(svm.support_)} / {len(y_eg)} "
      f"(payın tam üzerinde: {serbest.sum()}, α = C sınırında: {(~serbest).sum()})")
print(f"Karar fonksiyonu elle, Σ αᵢyᵢ k(xᵢ, x) + b: sklearn ile en büyük fark "
      f"{np.abs(f_elle - svm_boru.decision_function(X_te)).max():.1e}")
print(f"Pay üzerindeki destek vektörlerinde yᵢ f(xᵢ): {marj[serbest].min():.3f} – {marj[serbest].max():.3f}")
for ad, m in [("Aşırı esnek SVM (C = 1000, γ = 100)", asiri), ("Az uyumlu SVM  (C = 0.1, γ = 100) ", az)]:
    print(f"{ad}: eğitim {m.score(Z_eg, y_eg):.3f}, test {m.score(Z_te, y_te):.3f}, "
          f"destek vektörü {len(m.support_)}")
assert np.allclose(f_elle, svm_boru.decision_function(X_te), atol=1e-8)

# %% 6. Test kümesinde karşılaştırma
dogrusal = make_pipeline(StandardScaler(), LogisticRegression()).fit(X_eg, y_eg)
egri_dogruluk = np.mean((X_te[:, 1] > crr(X_te[:, 0])).astype(int) == y_te)
print("\n=== 6. Test kümesinde karşılaştırma (150 vaka) ===")
for ad, dg in [("CRR eğrisinin kendisi (CSR > CRR)", egri_dogruluk),
               ("Lojistik regresyon (doğrusal)", dogrusal.score(X_te, y_te)),
               (f"k-NN (k = {k_iyi})", knn_iyi.score(X_te, y_te)),
               (f"SVM (RBF, C = {C_iyi:.3g}, γ = {g_iyi:.3g})", svm_boru.score(X_te, y_te))]:
    print(f"{ad:34s}: {dg:.3f}")

# %% 7. Grafikler
NN, CC = np.meshgrid(np.linspace(5, 35, 200), np.linspace(0.05, 0.60, 200))
izgara = np.column_stack([NN.ravel(), CC.ravel()])
nn = np.linspace(5, 35, 300)


def veri_ve_egri(a, baslik):
    a.scatter(X_eg[y_eg == 0, 0], X_eg[y_eg == 0, 1], s=12, facecolors="none", edgecolors=SOLUK, lw=0.8)
    a.scatter(X_eg[y_eg == 1, 0], X_eg[y_eg == 1, 1], s=12, marker="x", color=SOLUK, lw=0.8)
    a.plot(nn, crr(nn), color=MUREKKEP, ls="--", lw=1.4)
    a.set(xlim=(5, 35), ylim=(0.05, 0.6), title=baslik)


# Şekil 1: k-NN karar sınırları
fig, ax = plt.subplots(2, 2, figsize=(10, 7.5), layout="constrained", sharex=True, sharey=True)
modeller = [(make_pipeline(StandardScaler(), KNeighborsClassifier(1)), "k = 1 (standartlaştırılmış)"),
            (knn_iyi, f"k = {k_iyi} (CV ile seçilen)"),
            (make_pipeline(StandardScaler(), KNeighborsClassifier(181)), "k = 181 (aşırı düzgün)"),
            (KNeighborsClassifier(k_iyi), f"k = {k_iyi}, ölçeklemeden (ham birimler)")]
for a, (m, baslik) in zip(ax.ravel(), modeller):
    m.fit(X_eg, y_eg)
    p = m.predict_proba(izgara)[:, 1].reshape(NN.shape)
    a.contourf(NN, CC, p, levels=[0.5, 1.01], colors=[RENK[0]], alpha=0.10)
    a.contour(NN, CC, p, levels=[0.5], colors=[RENK[0]], linewidths=1.8)
    veri_ve_egri(a, f"{baslik}: test {m.score(X_te, y_te):.3f}")
for a in ax[1]:
    a.set_xlabel("(N1)60cs (darbe/30 cm)")
for a in ax[:, 0]:
    a.set_ylabel("CSR (M = 7.5, σ′v = 1 atm)")
tutamak = [Line2D([], [], marker="x", ls="none", color=SOLUK, label="Sıvılaştı (eğitim)"),
           Line2D([], [], marker="o", ls="none", mfc="none", mec=SOLUK, label="Sıvılaşmadı (eğitim)"),
           Line2D([], [], color=RENK[0], label="k-NN sınırı (p = 0.5)"),
           Line2D([], [], color=MUREKKEP, ls="--", lw=1.4, label="CRR eğrisi (Idriss–Boulanger)")]
fig.legend(handles=tutamak, loc="outside lower center", ncol=4, fontsize=9)
kaydet(fig, "d06_knn_svm_1.png")

# Şekil 2: doğrulama eğrisi ve boyut laneti
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].semilogx(k_listesi, egt_ort, "-o", ms=4, color=RENK[0], label="Eğitim doğruluğu")
ax[0].semilogx(k_listesi, cv_ort, "-o", ms=4, color=RENK[1], label="5 katlı CV doğruluğu")
ax[0].axvline(k_iyi, color=MUREKKEP, ls="--", lw=1.2, label=f"Seçilen k = {k_iyi}")
ax[0].set(xlabel="Komşu sayısı k (log ölçek)", ylabel="Doğruluk", title="k: yanlılık–varyans düğmesi")
ax[0].legend(loc="lower left", fontsize=9)
ax[1].semilogx(boyutlar, oranlar, "-o", ms=4, color=RENK[0], label="Ortalama oran (50 sorgu)")
ax[1].axhline(1.0, color=IKINCIL, ls=":", lw=1.2, label="Tüm uzaklıklar eşit")
ax[1].set(xlabel="Boyut sayısı d (log ölçek)", ylabel="En yakın / en uzak uzaklık", ylim=(0, 1.05),
          title="Boyut laneti: uzaklıklar birbirine yaklaşır")
ax[1].legend(loc="lower right", fontsize=9)
kaydet(fig, "d06_knn_svm_2.png")

# Şekil 3: C–γ ızgarasında CV doğruluğu ve en iyi SVM'in sınırı
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
im = ax[0].imshow(izgara_cv, origin="lower", cmap="Blues", aspect="auto")
def etiket(v):
    return f"{v:.0f}" if v >= 100 else f"{v:.2g}"


ax[0].set_xticks(range(len(g_list)), [etiket(g) for g in g_list])
ax[0].set_yticks(range(len(C_list)), [etiket(c) for c in C_list])
i, j = np.unravel_index(np.argmax(izgara_cv), izgara_cv.shape)
ax[0].plot(j, i, marker="*", ms=14, color=RENK[1], ls="none")
ax[0].set(xlabel="γ (standartlaştırılmış özellikler)", ylabel="C",
          title="5 katlı CV doğruluğu (★ en iyi)")
ax[0].grid(False)
fig.colorbar(im, ax=ax[0], label="Doğruluk")
f_iz = svm_boru.decision_function(izgara).reshape(NN.shape)
ax[1].contourf(NN, CC, f_iz, levels=[0, f_iz.max() + 1], colors=[RENK[0]], alpha=0.10)
ax[1].contour(NN, CC, f_iz, levels=[0], colors=[RENK[0]], linewidths=1.8)
ax[1].contour(NN, CC, f_iz, levels=[-1, 1], colors=[RENK[0]], linewidths=1.0, linestyles=":")
veri_ve_egri(ax[1], f"SVM: C = {C_iyi:.3g}, γ = {g_iyi:.3g}")
sv = X_eg[svm.support_]
ax[1].scatter(sv[:, 0], sv[:, 1], s=40, facecolors="none", edgecolors=RENK[1], lw=1.0)
ax[1].set(xlabel="(N1)60cs (darbe/30 cm)", ylabel="CSR (M = 7.5, σ′v = 1 atm)")
tutamak = [Line2D([], [], color=RENK[0], label="Karar sınırı f = 0"),
           Line2D([], [], color=RENK[0], lw=1.0, ls=":", label="Pay f = ±1"),
           Line2D([], [], marker="o", ls="none", mfc="none", mec=RENK[1], label="Destek vektörü"),
           Line2D([], [], color=MUREKKEP, ls="--", lw=1.4, label="CRR eğrisi")]
ax[1].legend(handles=tutamak, loc="upper center", bbox_to_anchor=(0.5, -0.17), ncol=2, fontsize=8)
kaydet(fig, "d06_knn_svm_3.png")
print("\nGrafikler kaydedildi: d06_knn_svm_1.png, _2.png, _3.png")
