"""Ders 09 — Kümeleme: k-means, Gauss karışımı ve DBSCAN.

Sentetik bir koni penetrasyon deneyi (CPT) sondajındaki okumaları, etiket kullanmadan gruplara
ayırıyor ve bulunan kümeleri derinliğe geri taşıyıp gerçek tabakalarla karşılaştırıyoruz:
  * k-means'i Lloyd algoritmasıyla sıfırdan yazıp scikit-learn ile karşılaştırıyoruz,
  * rastgele ve k-means++ başlatmayı, yerel minimumları ve ölçeklemenin etkisini ölçüyoruz,
  * k'yi dirsek ve siluet ölçütleriyle, Gauss karışımında BIC ile seçiyoruz,
  * DBSCAN ile tek okumalık sıçramaları gürültü olarak ayıklıyoruz.

Veri sentetiktir: 0–20 m arasında 2 cm aralıkla 1001 okuma, dört tabaka (yumuşak kil, siltli kum,
katı kil, sıkı kum). Her tabakada uç direnci q_c log-normal, sürtünme oranı R_f normal dağılır;
derinlik boyunca ilişkili dalgalanma, tabaka sınırlarında geçiş ve 14 tek okumalık sıçrama eklenir.
Gerçek bir saha kaydı değildir. Zemin sınıflandırması için mühendislik standardı CPT abaklarıdır.

Çalıştır:  python d09_kumeleme.py
Gerekenler: numpy, scipy, scikit-learn, matplotlib  (Python 3.12+)
Çıktılar:  terminale sayılar, aynı klasöre dört PNG grafiği
"""
import os
os.environ.setdefault("OMP_NUM_THREADS", "1")  # küçük veride tek iş parçacığı: hızlı ve tekrarlanabilir

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 matplotlib.patches import Patch
from matplotlib.ticker import NullFormatter
from scipy.optimize import linear_sum_assignment
from scipy.stats import multivariate_normal
from sklearn.cluster import DBSCAN, AgglomerativeClustering, KMeans
from sklearn.metrics import adjusted_rand_score, silhouette_score
from sklearn.mixture import GaussianMixture
from sklearn.neighbors import NearestNeighbors
from sklearn.preprocessing import 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 CPT sondajı
rng = np.random.default_rng(42)
DZ = 0.02                                        # okuma aralığı (m)
z = np.round(np.arange(0, 20 + DZ / 2, DZ), 2)   # derinlik (m)
n = len(z)
# (ad, üst, alt, log10 q_c üstte, log10 q_c altta, log10 q_c std, R_f ort. %, R_f std %, korelasyon)
TABAKA = [("Yumuşak kil", 0.0, 4.6, -0.35, -0.10, 0.06, 4.6, 0.60, -0.3),
          ("Siltli kum", 4.6, 9.2, 0.62, 0.75, 0.12, 1.7, 0.35, -0.5),
          ("Katı kil", 9.2, 13.8, 0.28, 0.36, 0.07, 5.2, 0.60, -0.3),
          ("Sıkı kum", 13.8, 20.0, 1.15, 1.30, 0.10, 0.8, 0.18, -0.5)]
ADLAR = [t[0] for t in TABAKA]
gercek = np.zeros(n, dtype=int)
mu_q, mu_r, sd_q, sd_r, kor = (np.zeros(n) for _ in range(5))
for k, (ad, ust, alt, q_ust, q_alt, sq, rf, sr, rh) in enumerate(TABAKA):
    m = (z >= ust) & ((z < alt) if k < len(TABAKA) - 1 else (z <= alt))
    gercek[m] = k
    mu_q[m] = q_ust + (q_alt - q_ust) * (z[m] - ust) / (alt - ust)   # q_c derinlikle artar
    mu_r[m], sd_q[m], sd_r[m], kor[m] = rf, sq, sr, rh


def yumusat(a, s=0.04):
    """Tabaka sınırında geçiş: ortalama profili Gauss çekirdeğiyle (σ = 4 cm) yumuşat."""
    u = np.arange(-10, 11) * DZ
    w = np.exp(-0.5 * (u / s) ** 2)
    return np.convolve(np.pad(a, 10, mode="edge"), w / w.sum(), mode="valid")


mu_q, mu_r = yumusat(mu_q), yumusat(mu_r)
phi = np.exp(-DZ / 0.15)                      # derinlikte ilişkili dalgalanma, ölçek 15 cm (AR(1))
e = np.zeros((n, 2))
for i in range(n):
    yeni = rng.normal(size=2)
    e[i] = yeni if i == 0 else phi * e[i - 1] + np.sqrt(1 - phi**2) * yeni
log_qc = mu_q + sd_q * e[:, 0]
Rf = mu_r + sd_r * (kor * e[:, 0] + np.sqrt(1 - kor**2) * e[:, 1])
sicrama = np.sort(rng.choice(np.arange(25, n - 25), size=14, replace=False))  # tek okumalık sıçramalar
log_qc[sicrama] += np.log10(rng.uniform(2.5, 5.0, sicrama.size))
Rf[sicrama] *= rng.uniform(1.6, 2.4, sicrama.size)
qc = 10.0**log_qc                             # uç direnci (MPa)
X_ham = np.column_stack([log_qc, Rf])
olcek = StandardScaler().fit(X_ham)
X = olcek.transform(X_ham)                    # standartlaştırılmış (log10 q_c, R_f)
assert np.all(np.isfinite(X)) and X.shape == (n, 2)

print("=== 1. Veri: sentetik CPT sondajı ===")
print(f"Okuma: {n} (0–20 m, {DZ*100:.0f} cm aralık), {len(TABAKA)} tabaka, "
      f"{sicrama.size} tek okumalık sıçrama; q_c {qc.min():.2f}–{qc.max():.1f} MPa")
for k, (ad, ust, alt, *_) in enumerate(TABAKA):
    m = gercek == k
    print(f"  {ad:12s} {ust:4.1f}–{alt:4.1f} m: q_c medyan {np.median(qc[m]):5.2f} MPa, "
          f"R_f ort. {Rf[m].mean():.2f} %")
print(f"Özellikler: log10 q_c (std {olcek.scale_[0]:.2f}) ve R_f (std {olcek.scale_[1]:.2f} %), "
      "ikisi de standartlaştırıldı")


# %% 2. k-means: Lloyd algoritması, sıfırdan
def lloyd(X, merkez, en_cok=100):
    """k-means için Lloyd algoritması: atama ve güncelleme adımlarını sırayla tekrarlar."""
    inertia = []
    for _ in range(en_cok):
        d2 = ((X[:, None, :] - merkez[None, :, :]) ** 2).sum(axis=2)   # (n, k) kare uzaklıklar
        etiket = d2.argmin(axis=1)                                     # atama: en yakın merkez
        inertia.append(d2[np.arange(len(X)), etiket].sum())
        yeni = np.array([X[etiket == j].mean(axis=0) if np.any(etiket == j) else merkez[j]
                         for j in range(len(merkez))])                 # güncelleme: küme ortalaması
        if np.allclose(yeni, merkez):
            break
        merkez = yeni
    return etiket, merkez, np.array(inertia)


def kmeanspp(X, k, rng):
    """k-means++: her yeni merkez, en yakın merkeze kare uzaklıkla orantılı olasılıkla seçilir."""
    merkez = [X[rng.integers(len(X))]]
    for _ in range(k - 1):
        d2 = ((X[:, None, :] - np.array(merkez)[None]) ** 2).sum(axis=2).min(axis=1)
        merkez.append(X[rng.choice(len(X), p=d2 / d2.sum())])
    return np.array(merkez)


K = 4
deneme = {"rastgele": [], "k-means++": []}
for _ in range(50):
    baslangiclar = [("rastgele", X[rng.choice(n, K, replace=False)]), ("k-means++", kmeanspp(X, K, rng))]
    for ad, baslangic in baslangiclar:
        etiket, merkez, inertia = lloyd(X, baslangic)
        assert np.all(np.diff(inertia) <= 1e-9)          # inertia hiçbir adımda artmaz
        deneme[ad].append((inertia, etiket, merkez))
en_iyi = min(d[0][-1] for liste in deneme.values() for d in liste)
km = KMeans(K, n_init=10, random_state=42).fit(X)
_, et_biz, mz_biz = min(deneme["k-means++"], key=lambda d: d[0][-1])
print("\n=== 2. k-means: Lloyd algoritması (sıfırdan) ===")
for ad, liste in deneme.items():
    son = np.array([d[0][-1] for d in liste])
    print(f"{ad:10s}: en iyi inertiaya ({en_iyi:.2f}) ulaşan {np.sum(son < en_iyi * (1 + 1e-4))}/50 deneme; "
          f"en kötü {son.max():.2f}, ortalama iterasyon {np.mean([len(d[0]) for d in liste]):.1f}")
yerel = np.unique(np.round([d[0][-1] for liste in deneme.values() for d in liste], 2))
print(f"100 denemede iki ondalıkta {yerel.size} farklı sonuç (yerel minimum): "
      f"{yerel.min():.2f} – {yerel.max():.2f}")
print(f"scikit-learn KMeans (n_init=10): inertia {km.inertia_:.2f}; bizim çözümle ARI "
      f"{adjusted_rand_score(km.labels_, et_biz):.3f}")
assert np.isclose(km.inertia_, en_iyi)
ari_km = adjusted_rand_score(gercek, km.labels_)
print(f"k-means (k = 4) ile gerçek tabakalar: ARI = {ari_km:.3f}")
ari_olcek = {ad: adjusted_rand_score(gercek, KMeans(K, n_init=10, random_state=42).fit(A).labels_)
             for ad, A in [("ham q_c (MPa), R_f", np.column_stack([qc, Rf])), ("log10 q_c, R_f", X_ham)]}
print("Ölçeklemenin etkisi (ARI): " + " | ".join(f"{a} {v:.3f}" for a, v in ari_olcek.items())
      + f" | standartlaştırılmış {ari_km:.3f}")

# %% 3. k seçimi: dirsek ve siluet
K_LISTE = list(range(1, 9))
inertia_k = [KMeans(k, n_init=10, random_state=42).fit(X).inertia_ for k in K_LISTE]
siluet_k = [silhouette_score(X, KMeans(k, n_init=10, random_state=42).fit_predict(X)) for k in K_LISTE[1:]]
print("\n=== 3. k seçimi ===")
print("k        " + "".join(f"{k:8d}" for k in K_LISTE))
print("inertia  " + "".join(f"{v:8.1f}" for v in inertia_k))
print("siluet   " + " " * 8 + "".join(f"{v:8.3f}" for v in siluet_k))

# %% 4. Gauss karışımı (EM) ve BIC
TURLER = ["full", "tied", "diag", "spherical"]


def karisim(k, tur="full", tol=1e-6):
    """EM ile Gauss karışımı. Varsayılan tol=1e-3 bu veride EM'i yakınsamadan durduruyor."""
    return GaussianMixture(k, covariance_type=tur, n_init=3, tol=tol, max_iter=1000, random_state=42).fit(X)


bic = {t: [karisim(k, t).bic(X) for k in K_LISTE] for t in TURLER}
gmm = karisim(K)
gmm_gevsek = karisim(K, tol=1e-3)
olas = gmm.predict_proba(X)
# E-adımını elle yapıp kütüphaneyle karşılaştır: γ_ik = π_k N(x_i | μ_k, Σ_k) / Σ_j π_j N(x_i | μ_j, Σ_j)
pay = np.column_stack([gmm.weights_[k] * multivariate_normal(gmm.means_[k], gmm.covariances_[k]).pdf(X)
                       for k in range(K)])
assert np.allclose(pay / pay.sum(axis=1, keepdims=True), olas)
et_gmm = olas.argmax(axis=1)
ari_gmm = adjusted_rand_score(gercek, et_gmm)
belirsiz = olas.max(axis=1) < 0.9
sinirlar = np.array([t[2] for t in TABAKA[:-1]])
sinira_uzaklik = np.abs(z[:, None] - sinirlar[None]).min(axis=1)
k_bic = int(np.argmin(bic["full"])) + 1
gmm_bic = karisim(k_bic)
agirlik = np.sort(gmm_bic.weights_)[::-1] * n
print("\n=== 4. Gauss karışımı (EM) ===")
print("BIC, k =        " + "".join(f"{k:8d}" for k in K_LISTE) + "   en iyi k")
for t, b in bic.items():
    print(f"  {t:13s}" + "".join(f"{v:8.0f}" for v in b) + f"{int(np.argmin(b)) + 1:8d}")
print(f"Komşu okumalar arası korelasyon φ = {phi:.3f}; ortalama için etkin örnek sayısı "
      f"n(1 − φ)/(1 + φ) ≈ {n * (1 - phi) / (1 + phi):.0f}")
print(f"k = 4, tam kovaryans: ARI {ari_gmm:.3f}; elle yapılan E-adımı predict_proba ile aynı")
print(f"Log-olabilirlik: tol=1e-6 ile {gmm.score(X) * n:.2f} ({gmm.n_iter_} iterasyon); "
      f"varsayılan tol=1e-3 ile {gmm_gevsek.score(X) * n:.2f} ({gmm_gevsek.n_iter_} iterasyon, "
      f"ARI {adjusted_rand_score(gercek, gmm_gevsek.predict(X)):.3f})")
sicrama_belirsiz = np.isin(np.flatnonzero(belirsiz), sicrama).sum()
print(f"Belirsiz okuma (en büyük olasılık < 0.9): {belirsiz.sum()} (sınıra 20 cm'den yakın "
      f"{np.sum(belirsiz & (sinira_uzaklik <= 0.2))}, sıçrama {sicrama_belirsiz})")
parca = []
for k, ad in enumerate(ADLAR):
    zk = z[belirsiz & (gercek == k)]
    if zk.size:
        parca.append(f"{ad} {zk.size} ({zk[0]:.2f} m)" if zk.size == 1 else
                     f"{ad} {zk.size} ({zk[0]:.2f}–{zk[-1]:.2f} m)")
print("  tabakalara göre: " + ", ".join(parca))
et_bic = gmm_bic.predict(X)
kucuk = np.flatnonzero(et_bic == np.argmin(gmm_bic.weights_))     # en küçük bileşenin okumaları
print(f"k = {k_bic} (BIC seçimi): ARI {adjusted_rand_score(gercek, et_bic):.3f}; bileşenlerin beklenen okuma "
      f"sayıları {', '.join(f'{a:.0f}' for a in agirlik)}")
print(f"  en küçük bileşene atanan {kucuk.size} okuma: sıçrama {np.isin(kucuk, sicrama).sum()}, "
      f"sınıra 20 cm'den yakın {np.sum(sinira_uzaklik[kucuk] <= 0.2)}")

# %% 5. DBSCAN: yoğunluk tabanlı kümeler ve gürültü
MIN_ORNEK, EPS = 30, 0.20
k_uzaklik = np.sort(NearestNeighbors(n_neighbors=MIN_ORNEK).fit(X).kneighbors(X)[0][:, -1])
db = DBSCAN(eps=EPS, min_samples=MIN_ORNEK).fit(X)
et_db = db.labels_
gurultu = et_db == -1
print("\n=== 5. DBSCAN ===")
print(f"{MIN_ORNEK}. komşuya uzaklık (nokta kendisi dahil): medyan {np.median(k_uzaklik):.3f}, "
      f"%90'lık {np.quantile(k_uzaklik, 0.9):.3f}, %95'lik {np.quantile(k_uzaklik, 0.95):.3f}")
print(f"min_samples = {MIN_ORNEK}, eps = {EPS:.2f}: {et_db.max() + 1} küme, {gurultu.sum()} gürültü okuması "
      f"(14 sıçramanın {gurultu[sicrama].sum()}'ü, {gurultu.sum() - gurultu[sicrama].sum()} diğer okuma)")
print(f"ARI: gürültü hariç {adjusted_rand_score(gercek[~gurultu], et_db[~gurultu]):.3f}, "
      f"gürültü ayrı küme sayılırsa {adjusted_rand_score(gercek, et_db):.3f}")
et_db2 = DBSCAN(eps=0.25, min_samples=MIN_ORNEK).fit(X).labels_
print(f"eps = 0.25 ile: {et_db2.max() + 1} küme, {np.sum(et_db2 == -1)} gürültü okuması")
assert gurultu[sicrama].sum() >= 12


def tabakaya_esle(etiket):
    """Küme numaralarını en çok örtüştükleri tabakaya eşle (renkler sütunlar arasında tutarlı olsun)."""
    kumeler = [c for c in np.unique(etiket) if c >= 0]
    tablo = np.array([[np.sum((etiket == c) & (gercek == t)) for t in range(len(TABAKA))] for c in kumeler])
    sat, sut = linear_sum_assignment(-tablo)
    esle = {kumeler[i]: j for i, j in zip(sat, sut)}
    return np.array([esle.get(c, -1) for c in etiket])


# %% 6. Hiyerarşik kümeleme (Ward) ve özet
et_ward = AgglomerativeClustering(K, linkage="ward").fit_predict(X)
print("\n=== 6. Karşılaştırma (bütün okumalarla, gerçek tabakalara göre ARI) ===")
print(f"k-means {ari_km:.3f} | Gauss karışımı {ari_gmm:.3f} | DBSCAN, gürültü ayrı küme "
      f"{adjusted_rand_score(gercek, et_db):.3f} | Ward {adjusted_rand_score(gercek, et_ward):.3f}")
esle_km, esle_gmm = tabakaya_esle(km.labels_), tabakaya_esle(et_gmm)
sic = np.isin(np.arange(n), sicrama)
km_kar, gmm_kar = (gercek == 1) & (esle_km == 3), (gercek == 3) & (esle_gmm == 1)
print(f"Karışan okumalar: k-means'te siltli kumdan sıkı kuma {km_kar.sum()} ({np.sum(km_kar & sic)} sıçrama), "
      f"Gauss karışımında sıkı kumdan siltli kuma {gmm_kar.sum()} ({np.sum(gmm_kar & sic)} sıçrama; "
      f"sıkı kumdaki sıçrama sayısı {np.sum(sic & (gercek == 3))})")


# %% 7. Grafikler
renk_km, renk_gmm, renk_db = tabakaya_esle(km.labels_), tabakaya_esle(et_gmm), tabakaya_esle(et_db)
TR = np.array(RENK[:4])
merkez_ham = olcek.inverse_transform(km.cluster_centers_)


def ozellik_ekseni(a, baslik):
    a.set_xscale("log")
    a.set_xticks([0.3, 1, 3, 10, 30, 100], ["0.3", "1", "3", "10", "30", "100"])
    a.set(xlabel="Uç direnci $q_c$ (MPa, log ölçek)", ylabel="Sürtünme oranı $R_f$ (%)", title=baslik)


# Şekil 1: özellik uzayında dört görünüm
fig, ax = plt.subplots(2, 2, figsize=(10, 7.5), layout="constrained", sharex=True, sharey=True)
ax = ax.ravel()
ax[0].scatter(qc, Rf, s=6, c=TR[gercek], lw=0, antialiased=False)
ax[0].scatter(qc[sicrama], Rf[sicrama], s=40, marker="x", color=MUREKKEP, label="sıçrama")
ax[0].legend(handles=[Patch(color=RENK[k], label=a) for k, a in enumerate(ADLAR)]
             + [Line2D([], [], marker="x", ls="none", color=MUREKKEP, label="sıçrama")], loc="upper right")
ozellik_ekseni(ax[0], "Gerçek tabakalar (etiketler kümelemede kullanılmaz)")
ax[1].scatter(qc, Rf, s=6, c=TR[renk_km], lw=0, antialiased=False)
ax[1].scatter(10 ** merkez_ham[:, 0], merkez_ham[:, 1], s=160, marker="X", color=MUREKKEP, edgecolor="white",
              label="küme merkezi")
ax[1].legend(loc="center right")
ozellik_ekseni(ax[1], f"k-means, k = 4 (ARI = {ari_km:.3f})")
ax[2].scatter(qc[~belirsiz], Rf[~belirsiz], s=6, c=TR[renk_gmm[~belirsiz]], lw=0, antialiased=False)
ax[2].scatter(qc[belirsiz], Rf[belirsiz], s=22, c=TR[renk_gmm[belirsiz]], edgecolor=MUREKKEP, lw=0.8,
              label="en büyük olasılık < 0.9")
aci = np.linspace(0, 2 * np.pi, 100)
S = np.diag(olcek.scale_)
for k in range(K):
    C = S @ gmm.covariances_[k] @ S                       # kovaryansı asıl birimlere çevir
    deger, vektor = np.linalg.eigh(C)
    elips = (vektor @ np.diag(2 * np.sqrt(deger)) @ np.vstack([np.cos(aci), np.sin(aci)])).T
    elips += olcek.inverse_transform(gmm.means_[k:k + 1])
    ax[2].plot(10 ** elips[:, 0], elips[:, 1], color=MUREKKEP, lw=1.2)
ax[2].legend(loc="center right")
ozellik_ekseni(ax[2], f"Gauss karışımı, 2σ elipsleri (ARI = {ari_gmm:.3f})")
ax[3].scatter(qc[~gurultu], Rf[~gurultu], s=6, c=TR[renk_db[~gurultu]], lw=0, antialiased=False)
ax[3].scatter(qc[gurultu], Rf[gurultu], s=30, marker="x", color=MUREKKEP,
              label=f"gürültü ({gurultu.sum()} okuma)")
ax[3].legend(loc="center right")
ozellik_ekseni(ax[3], f"DBSCAN, eps = {EPS}, min_samples = {MIN_ORNEK}")
for a in ax:
    a.label_outer()
fig.savefig(KLASOR / "d09_kumeleme_1.png", dpi=160)
plt.close(fig)

# Şekil 2: Lloyd iterasyonları, dirsek ve siluet
fig, ax = plt.subplots(1, 3, figsize=(10, 4.2), layout="constrained")
for inertia, *_ in deneme["rastgele"][:12]:
    ax[0].plot(np.arange(1, len(inertia) + 1), inertia, color=SOLUK, lw=1, alpha=0.8)
for inertia, *_ in deneme["k-means++"][:12]:
    ax[0].plot(np.arange(1, len(inertia) + 1), inertia, color=RENK[0], lw=1.2, alpha=0.8)
ax[0].axhline(en_iyi, color=MUREKKEP, ls=":", lw=1.2)
ax[0].legend(handles=[Line2D([], [], color=SOLUK, label="rastgele başlatma"),
                      Line2D([], [], color=RENK[0], label="k-means++"),
                      Line2D([], [], color=MUREKKEP, ls=":", label="en iyi inertia")], loc="upper right")
ax[0].set_yscale("log")
ax[0].set_yticks([150, 200, 300, 500, 1000, 2000], ["150", "200", "300", "500", "1000", "2000"])
ax[0].yaxis.set_minor_formatter(NullFormatter())
ax[0].set(xlabel="İterasyon", ylabel="Inertia (standart birim²)",
          title="Lloyd: monoton azalma, yerel minimum")
ax[1].plot(K_LISTE, inertia_k, "o-", color=RENK[0])
ax[1].axvline(4, color=MUREKKEP, ls=":", lw=1.2)
ax[1].set(xlabel="Küme sayısı k", ylabel="Inertia (standart birim²)", title="Dirsek yöntemi")
ax[2].plot(K_LISTE[1:], siluet_k, "o-", color=RENK[1])
ax[2].axvline(4, color=MUREKKEP, ls=":", lw=1.2)
ax[2].set(xlabel="Küme sayısı k", ylabel="Ortalama siluet katsayısı", title="Siluet ölçütü")
fig.savefig(KLASOR / "d09_kumeleme_2.png", dpi=160)
plt.close(fig)

# Şekil 3: BIC ve k-uzaklık eğrisi
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for j, t in enumerate(TURLER):
    ax[0].plot(K_LISTE, bic[t], "o-", color=RENK[j], ms=4, label=t)
ax[0].axvline(4, color=MUREKKEP, ls=":", lw=1.2)
ax[0].set(xlabel="Bileşen sayısı k", ylabel="BIC (küçük daha iyi)", title="Gauss karışımı: BIC")
ax[0].legend(title="covariance_type", loc="upper right")
ax[1].plot(np.arange(1, n + 1), k_uzaklik, color=RENK[0])
ax[1].axhline(EPS, color=MUREKKEP, ls=":", lw=1.2, label=f"seçilen eps = {EPS}")
ax[1].axhline(0.25, color=RENK[1], ls="--", lw=1.2, label="eps = 0.25: iki kum birleşir")
ax[1].set(xlabel="Okumalar (uzaklığa göre sıralı)", ylabel=f"{MIN_ORNEK}. komşuya uzaklık (standart birim)",
          title="DBSCAN için k-uzaklık eğrisi", ylim=(0, 1.0))
ax[1].legend(loc="upper left")
fig.savefig(KLASOR / "d09_kumeleme_3.png", dpi=160)
plt.close(fig)

# Şekil 4: zemin kolonu — ölçümler ve kümelerin derinliğe dönüşü
fig, ax = plt.subplots(1, 6, figsize=(10, 7.5), layout="constrained", sharey=True,
                       gridspec_kw={"width_ratios": [2.2, 2.2, 1, 1, 1, 1]})
ax[0].plot(qc, z, color=MUREKKEP, lw=0.8)
ax[0].plot(qc[sicrama], z[sicrama], "x", color=RENK[7], ms=6)
ax[0].set_xscale("log")
ax[0].set_xticks([0.3, 1, 3, 10, 30, 100], ["0.3", "1", "3", "10", "30", "100"])
ax[0].set(xlabel="$q_c$ (MPa)", ylabel="Derinlik (m)", title="Uç direnci")
ax[1].plot(Rf, z, color=MUREKKEP, lw=0.8)
ax[1].plot(Rf[sicrama], z[sicrama], "x", color=RENK[7], ms=6)
ax[1].set(xlabel="$R_f$ (%)", title="Sürtünme oranı")
for a, et, baslik in [(ax[2], gercek, "Gerçek"), (ax[3], renk_km, "k-means"),
                      (ax[4], renk_gmm, "Gauss\nkarışımı"), (ax[5], renk_db, "DBSCAN")]:
    renkler = np.array([TR[e] if e >= 0 else MUREKKEP for e in et])
    a.barh(z, np.ones(n), height=DZ, color=renkler, linewidth=0)
    a.set(xlim=(0, 1), xticks=[], title=baslik)
    a.grid(False)
ax[4].plot(np.full(belirsiz.sum(), 0.85), z[belirsiz], "<", color=MUREKKEP, ms=4)   # belirsiz okumalar
ax[0].invert_yaxis()
for a in ax[2:]:
    for s_ in sinirlar:
        a.axhline(s_, color=MUREKKEP, lw=0.6, ls=":")
fig.legend(handles=[Patch(color=RENK[k], label=a) for k, a in enumerate(ADLAR)]
           + [Patch(color=MUREKKEP, label="DBSCAN gürültüsü"),
              Line2D([], [], marker="<", ls="none", color=MUREKKEP, label="olasılık < 0.9")],
           loc="outside lower center", ncol=3)
fig.savefig(KLASOR / "d09_kumeleme_4.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d09_kumeleme_1.png, _2.png, _3.png, _4.png")
