"""Ders 13 — Evrişimli sinir ağları ile çatlak tespiti.

Önce evrişimi NumPy ile sıfırdan yazıp Sobel kenar filtrelerini sentetik bir çatlak görüntüsüne
uyguluyoruz. Sonra 64×64 piksellik gri tonlu "beton yüzeyi" görüntülerinde çatlak olup olmadığını
küçük bir evrişimli sinir ağıyla (CNN) sınıflandırıyor, iki basit lojistik regresyon modeliyle
karşılaştırıyoruz. Veri tamamen sentetiktir ve betikte üretilir: yumuşatılmış gürültü dokusu,
agrega taneleri, lekeler; çatlaklı görüntülerde rastgele yürüyüşle çizilen koyu bir kırık çizgi,
çatlaksız görüntülerde ise dikkat dağıtıcılar (düz derz çizgileri, lekeler, kısa çizikler).
Gerçek fotoğraf değildir; ışık, kamera ve yüzey çeşitliliği gerçek verideki kadar geniş değildir.

Çalıştır:  python d13_cnn_catlak.py
Gerekenler: numpy, scipy, scikit-learn, matplotlib, torch  (Python 3.12+; CPU yeterli)
Süre:      yaklaşık 1–3 dk
Çıktılar:  terminale sayılar, aynı klasöre dört PNG grafiği
"""
import copy
from pathlib import Path

import numpy as np
from scipy.ndimage import gaussian_filter
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.metrics import confusion_matrix, precision_score, recall_score

# --- 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)
torch.manual_seed(42)
N = 64                                          # görüntü kenarı (piksel)
yy, xx = np.mgrid[0:N, 0:N].astype(float)


# %% 1. Sentetik beton yüzeyi görüntüleri
def doku(rng):
    """Taban gri ton + iki ölçekli yumuşatılmış gürültü + ışık eğimi + agrega taneleri/gözenekler."""
    img = rng.uniform(0.45, 0.70) + rng.normal(0, 0.015, (N, N))
    for olcek, genlik in [(6.0, 0.05), (1.0, 0.03)]:
        g = gaussian_filter(rng.normal(size=(N, N)), olcek, mode="wrap")
        img += genlik * g / g.std()
    aci = rng.uniform(0, 2 * np.pi)
    img += rng.uniform(0, 0.10) * (np.cos(aci) * (xx - 32) + np.sin(aci) * (yy - 32)) / 45
    for _ in range(rng.integers(6, 20)):
        cx, cy, r = rng.uniform(0, N), rng.uniform(0, N), rng.uniform(0.8, 2.8)
        genlik = rng.uniform(0.04, 0.12) * rng.choice([-1, 1], p=[0.4, 0.6])
        us = np.clip(((xx - cx)**2 + (yy - cy)**2 - r**2) / (0.6 * r), -50, 50)
        img += genlik / (1 + np.exp(us))                         # yumuşak kenarlı disk
    return img


def leke(img, rng):
    cx, cy = rng.uniform(0, N, 2)
    sx, sy = rng.uniform(5, 14, 2)
    return img - rng.uniform(0.06, 0.16) * np.exp(-((xx - cx)**2 / (2 * sx**2) + (yy - cy)**2 / (2 * sy**2)))


PIKSEL = np.stack([xx.ravel(), yy.ravel()], axis=1)            # (4096, 2) piksel merkezleri


def cizgi_ciz(img, noktalar, genislik, koyuluk):
    """Kırık çizgiyi yumuşak kenarlı çiz: her pikselin en yakın doğru parçasına uzaklığı."""
    A = np.asarray(noktalar[:-1], dtype=float)                   # parça başlangıçları (S, 2)
    V = np.asarray(noktalar[1:], dtype=float) - A                # parça vektörleri
    D = PIKSEL[:, None, :] - A[None]                             # (4096, S, 2)
    s = np.clip((D * V).sum(-1) / ((V * V).sum(-1) + 1e-12), 0, 1)
    d = np.linalg.norm(D - s[..., None] * V[None], axis=-1).min(axis=1)
    return img - koyuluk * np.clip(0.5 + genislik / 2 - d.reshape(N, N), 0, 1)


def rastgele_yuruyus(x, y, yon, adim_sayisi, rng, sapma=0.25):
    pts = [(x, y)]
    for _ in range(adim_sayisi):
        yon += rng.normal(0, sapma) + (rng.choice([-0.7, 0.7]) if rng.random() < 0.08 else 0.0)
        x, y = x + 2.0 * np.cos(yon), y + 2.0 * np.sin(yon)
        pts.append((x, y))
        if not (-3 < x < N + 3 and -3 < y < N + 3):
            break
    return pts


def catlak(img, rng):
    """Kenardan başlayan, yönünü koruyan rastgele yürüyüş (+ olası dal); genişlik 1–2,2 px, koyu."""
    while True:
        kenar, s = rng.integers(4), rng.uniform(6, 58)
        x, y = [(s, 0.0), (64.0, s), (s, 64.0), (0.0, s)][kenar]
        yon = [np.pi / 2, np.pi, -np.pi / 2, 0.0][kenar] + rng.uniform(-0.7, 0.7)
        pts = rastgele_yuruyus(x, y, yon, 45, rng)
        icerde = sum(0 <= px < N and 0 <= py < N for px, py in pts)
        if icerde >= 12:
            break
    gen, koyu = rng.uniform(1.0, 2.2), rng.uniform(0.15, 0.32)
    img = cizgi_ciz(img, pts, gen, koyu)
    if rng.random() < 0.35:                                       # dal
        i = rng.integers(len(pts) // 4, max(len(pts) // 4 + 1, 3 * len(pts) // 4))
        yon = rng.uniform(0, 2 * np.pi)
        img = cizgi_ciz(img, rastgele_yuruyus(*pts[i], yon, rng.integers(6, 16), rng), 0.7 * gen, koyu)
    return img


def derz(img, rng):
    """Düz derz çizgisi: yatay, dikey ya da eğik; çatlaktan geniş (2,8–4,5 px), benzer koyulukta."""
    if rng.random() < 0.5:
        c = rng.uniform(8, 56)
        pts = [(0.0, c), (64.0, c)] if rng.random() < 0.5 else [(c, 0.0), (c, 64.0)]
    else:
        aci, c = rng.uniform(0, np.pi), rng.uniform(16, 48)
        pts = [(32 - 50 * np.cos(aci), c - 50 * np.sin(aci)), (32 + 50 * np.cos(aci), c + 50 * np.sin(aci))]
    return cizgi_ciz(img, pts, rng.uniform(2.8, 4.5), rng.uniform(0.10, 0.22))


def cizik(img, rng):
    """Kısa, ince, düz çizik."""
    x, y, aci, L = rng.uniform(10, 54), rng.uniform(10, 54), rng.uniform(0, np.pi), rng.uniform(6, 16)
    pts = [(x, y), (x + L * np.cos(aci), y + L * np.sin(aci))]
    return cizgi_ciz(img, pts, rng.uniform(1.0, 1.4), rng.uniform(0.08, 0.16))


def goruntu(etiket, rng):
    """Görüntüyü ve hangi dikkat dağıtıcıların eklendiğini döndürür."""
    var = {"derz": False, "leke": False, "çizik": False}
    img = doku(rng)
    if rng.random() < 0.4:
        img, var["leke"] = leke(img, rng), True
    p_derz = 0.3 if etiket == 1 else 0.6                         # derz çatlaksızlarda daha sık
    if rng.random() < p_derz:
        img, var["derz"] = derz(img, rng), True
    if rng.random() < 0.25:
        img, var["çizik"] = cizik(img, rng), True
    if etiket == 1:
        img = catlak(img, rng)
    elif rng.random() < 0.3:                                      # çatlaksızlara ikinci leke şansı
        img, var["leke"] = leke(img, rng), True
    return np.clip(img, 0, 1), var


n_toplam = 3000
y_tum = rng.permutation(np.repeat([0, 1], n_toplam // 2))
uretim = [goruntu(e, rng) for e in y_tum]
X_tum = np.stack([u[0] for u in uretim]).astype(np.float32)
dikkat = {k: np.array([u[1][k] for u in uretim]) for k in ("derz", "leke", "çizik")}
eg, dog, te = np.arange(2000), np.arange(2000, 2500), np.arange(2500, 3000)
koyu_oran = (X_tum < X_tum.mean(axis=(1, 2), keepdims=True) - 0.12).mean(axis=(1, 2))
print("=== 1. Sentetik veri ===")
print(f"{n_toplam} görüntü ({N}×{N}, gri ton), çatlaklı oranı %{100*y_tum.mean():.0f}; "
      f"eğitim/doğrulama/test = {len(eg)}/{len(dog)}/{len(te)}")
print("Dikkat dağıtıcı içeren görüntü oranı (çatlaklı / çatlaksız): " + ", ".join(
    f"{k} %{100*v[y_tum == 1].mean():.0f} / %{100*v[y_tum == 0].mean():.0f}" for k, v in dikkat.items()))
print(f"Koyu piksel oranı (ortalamadan 0.12 koyu): çatlaklı %{100*koyu_oran[y_tum == 1].mean():.1f} "
      f"± {100*koyu_oran[y_tum == 1].std():.1f}, çatlaksız %{100*koyu_oran[y_tum == 0].mean():.1f} "
      f"± {100*koyu_oran[y_tum == 0].std():.1f}")


# %% 2. Evrişim sıfırdan: NumPy ile çapraz korelasyon ve Sobel filtreleri
def evrisim2d(img, K, adim=1, dolgu=0, kip="constant"):
    """Y[i, j] = Σ_u Σ_v X[i·s + u, j·s + v] · K[u, v]  (derin öğrenmedeki 'evrişim').
    kip="constant": sıfır dolgu; kip="edge": kenar piksellerini tekrarla."""
    if dolgu:
        img = np.pad(img, dolgu, mode=kip)
    k = K.shape[0]
    H = (img.shape[0] - k) // adim + 1                          # = ⌊(n + 2p − k)/s⌋ + 1
    W = (img.shape[1] - k) // adim + 1
    Y = np.empty((H, W))
    for i in range(H):
        for j in range(W):
            Y[i, j] = np.sum(img[i * adim:i * adim + k, j * adim:j * adim + k] * K)
    return Y


SOBEL_X = np.array([[-1.0, 0.0, 1.0], [-2.0, 0.0, 2.0], [-1.0, 0.0, 1.0]])
SOBEL_Y = SOBEL_X.T
# Hem derz hem çatlak içeren örnek görüntü; katmanları ayrı çizdiğimiz için maskeleri biliyoruz.
rng_o = np.random.default_rng(3)
k0 = doku(rng_o)
k1 = derz(k0, rng_o)
k2 = catlak(k1, rng_o)
maske_derz, maske_catlak = (k0 - k1) > 0.05, (k1 - k2) > 0.05
ornek = np.clip(k2, 0, 1)
Gx = evrisim2d(ornek, SOBEL_X, dolgu=1, kip="edge")
Gy = evrisim2d(ornek, SOBEL_Y, dolgu=1, kip="edge")
Gbuyukluk = np.hypot(Gx, Gy)
Gx_s2 = evrisim2d(ornek, SOBEL_X, adim=2, dolgu=1)
Gx_sifir = evrisim2d(ornek, SOBEL_X, dolgu=1)
torch_sonuc = nn.functional.conv2d(torch.tensor(ornek)[None, None], torch.tensor(SOBEL_X)[None, None], padding=1)
fark = np.abs(torch_sonuc[0, 0].numpy() - Gx_sifir).max()
print("\n=== 2. Evrişim sıfırdan (NumPy) ===")
print(f"3×3 Sobel, dolgu 1: adım 1 → {Gx.shape[0]}×{Gx.shape[1]}, adım 2 → {Gx_s2.shape[0]}×{Gx_s2.shape[1]} "
      f"[⌊(64 + 2 − 3)/2⌋ + 1 = {(64 + 2 - 3) // 2 + 1}]")
print(f"NumPy döngüsü ile torch.nn.functional.conv2d arasındaki en büyük fark: {fark:.1e}")
tam_bagli = f"{64 * 64 * 16 * 64 * 64 + 16 * 64 * 64:,}".replace(",", ".")
print(f"Parametre: 3×3 evrişim, 1→16 kanal: {16 * 9 + 16}; "
      f"aynı 16×64×64 çıktıyı üreten tam bağlantılı katman: {tam_bagli}")
print(f"Örnek görüntüde ortalama |G|: çatlak piksellerinde {Gbuyukluk[maske_catlak].mean():.2f}, "
      f"derz piksellerinde {Gbuyukluk[maske_derz & ~maske_catlak].mean():.2f}, "
      f"diğer piksellerde {Gbuyukluk[~maske_catlak & ~maske_derz].mean():.2f}")
assert fark < 1e-12 and Gx_s2.shape == (32, 32)

# %% 3. Temel modeller: lojistik regresyon
def evrisim_toplu(X, K):
    """Aynı işlemin döngüsüz hâli: (n, 64, 64) yığın, sıfır dolgu 1, adım 1."""
    pencere = np.lib.stride_tricks.sliding_window_view(np.pad(X, ((0, 0), (1, 1), (1, 1))), (3, 3), axis=(1, 2))
    return np.einsum("nijuv,uv->nij", pencere, K)


assert np.allclose(evrisim_toplu(ornek[None], SOBEL_X)[0], Gx_sifir)


def el_ozellikleri(X):
    """Görüntü başına 6 sayı: ortalama, std, %5'lik değer, koyu piksel oranı, Sobel ortalaması ve %99'u."""
    g = np.hypot(evrisim_toplu(X, SOBEL_X), evrisim_toplu(X, SOBEL_Y)).reshape(len(X), -1)
    duz = X.reshape(len(X), -1)
    ort = duz.mean(axis=1, keepdims=True)
    return np.column_stack([duz.mean(1), duz.std(1), np.percentile(duz, 5, axis=1),
                            (duz < ort - 0.12).mean(1), g.mean(1), np.percentile(g, 99, axis=1)])


def kucult(X, b=4):
    return X.reshape(len(X), N // b, b, N // b, b).mean(axis=(2, 4)).reshape(len(X), -1)


print("\n=== 3. Temel modeller (lojistik regresyon) ===")
F_tum = el_ozellikleri(X_tum.astype(float))
temel = {}
for ad, F in [("El yapımı 6 özellik", F_tum), ("16×16 küçültülmüş pikseller", kucult(X_tum))]:
    lr = make_pipeline(StandardScaler(), LogisticRegression(max_iter=5000))
    lr.fit(F[eg], y_tum[eg])
    tahmin = lr.predict(F[te])
    temel[ad] = (np.mean(tahmin == y_tum[te]), precision_score(y_tum[te], tahmin),
                 recall_score(y_tum[te], tahmin))
    print(f"{ad:28s}: test doğruluğu %{100*temel[ad][0]:.1f}, kesinlik %{100*temel[ad][1]:.1f}, "
          f"duyarlılık %{100*temel[ad][2]:.1f}")


# %% 4. Evrişimli sinir ağı
class CatlakAgi(nn.Module):
    """3 × (Conv 3×3 – BatchNorm – ReLU – MaxPool 2×2) + küresel ortalama havuzlama + doğrusal çıkış."""
    def __init__(self, kanallar=(8, 16, 32)):
        super().__init__()
        katmanlar, c_g = [], 1
        for c in kanallar:
            katmanlar += [nn.Conv2d(c_g, c, 3, padding=1, bias=False), nn.BatchNorm2d(c),
                          nn.ReLU(), nn.MaxPool2d(2)]
            c_g = c
        self.govde = nn.Sequential(*katmanlar)
        self.cikis = nn.Linear(c_g, 1)

    def forward(self, x):                      # x: (N, 1, 64, 64)
        h = self.govde(x)                      # (N, 32, 8, 8)
        h = h.mean(dim=(2, 3))                 # küresel ortalama havuzlama → (N, 32)
        return self.cikis(h).squeeze(1)        # logit


def artir(xb, g):
    """Veri artırma: her örneğe rastgele 90°'lik dönme, ayna ve parlaklık/karşıtlık değişimi."""
    k = torch.randint(0, 4, (len(xb),), generator=g)
    out = torch.empty_like(xb)
    for r in range(4):
        m = k == r
        if m.any():
            out[m] = torch.rot90(xb[m], r, dims=(2, 3))
    ayna = torch.rand(len(xb), generator=g) < 0.5
    out[ayna] = torch.flip(out[ayna], dims=(3,))
    c = 0.8 + 0.4 * torch.rand(len(xb), 1, 1, 1, generator=g)
    b = 0.3 * (torch.rand(len(xb), 1, 1, 1, generator=g) - 0.5)
    return out * c + b


ort, std = X_tum[eg].mean(), X_tum[eg].std()                  # piksel normalleştirmesi (eğitimden)
T = lambda idx: torch.tensor((X_tum[idx] - ort) / std)[:, None]
Xe, Xd, Xt = T(eg), T(dog), T(te)
ye, yd = torch.tensor(y_tum[eg], dtype=torch.float32), torch.tensor(y_tum[dog], dtype=torch.float32)

torch.manual_seed(42)
model = CatlakAgi()
n_param = sum(p.numel() for p in model.parameters())
alici = 1
sicrama = 1
for _ in range(3):                                            # conv 3×3 (s=1) ve maxpool 2×2 (s=2)
    alici += 2 * sicrama
    alici += 1 * sicrama
    sicrama *= 2
print("\n=== 4. CNN ===")
parca = [sum(p.numel() for p in model.govde[4 * i:4 * i + 4].parameters()) for i in range(3)]
parca.append(sum(p.numel() for p in model.cikis.parameters()))
print(f"Mimari: 3 × (Conv3×3–BN–ReLU–MaxPool) + küresel ortalama havuzlama + Linear; "
      f"parametre: {' + '.join(map(str, parca))} = {n_param}; son katmanın alıcı alanı {alici}×{alici} piksel")
DONEM = 12
kayip_fn = nn.BCEWithLogitsLoss()
opt = torch.optim.Adam(model.parameters(), lr=3e-3)
planlayici = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=DONEM)   # öğrenme hızı kosinüsle azalır
yukleyici = DataLoader(TensorDataset(Xe, ye), batch_size=64, shuffle=True,
                       generator=torch.Generator().manual_seed(42))
g_artir = torch.Generator().manual_seed(42)
gecmis = {"egitim": [], "dogrulama": [], "dog_dogruluk": []}
en_iyi, en_iyi_durum = -1.0, None
for donem in range(DONEM):
    model.train()
    toplam = 0.0
    for xb, yb in yukleyici:
        opt.zero_grad()
        kayip = kayip_fn(model(artir(xb, g_artir)), yb)
        kayip.backward()
        opt.step()
        toplam += kayip.item() * len(xb)
    model.eval()
    with torch.no_grad():
        z = model(Xd)
        L_d = kayip_fn(z, yd).item()
        dogruluk = ((z > 0).float() == yd).float().mean().item()
    planlayici.step()
    gecmis["egitim"].append(toplam / len(Xe))
    gecmis["dogrulama"].append(L_d)
    gecmis["dog_dogruluk"].append(dogruluk)
    if dogruluk > en_iyi:
        en_iyi, en_iyi_durum, en_iyi_donem = dogruluk, copy.deepcopy(model.state_dict()), donem
    print(f"Dönem {donem + 1:2d}: eğitim kaybı {gecmis['egitim'][-1]:.3f}, doğrulama kaybı {L_d:.3f}, "
          f"doğrulama doğruluğu %{100*dogruluk:.1f}")
model.load_state_dict(en_iyi_durum)
model.eval()

# %% 5. Test sonuçları
with torch.no_grad():
    p_test = torch.sigmoid(model(Xt)).numpy()
y_test = y_tum[te]
tahmin = (p_test > 0.5).astype(int)
km = confusion_matrix(y_test, tahmin)
dog_cnn = np.mean(tahmin == y_test)
print(f"\n=== 5. Test sonuçları (en iyi doğrulama dönemi: {en_iyi_donem + 1}) ===")
print(f"CNN: doğruluk %{100*dog_cnn:.1f}, kesinlik %{100*precision_score(y_test, tahmin):.1f}, "
      f"duyarlılık %{100*recall_score(y_test, tahmin):.1f}")
print(f"Karışıklık matrisi [gerçek sağlam: TN {km[0, 0]}, FP {km[0, 1]}] "
      f"[gerçek çatlak: FN {km[1, 0]}, TP {km[1, 1]}]")
yanlis = np.flatnonzero(tahmin != y_test)
print(f"Yanlış sınıflanan {len(yanlis)} görüntü: {km[0, 1]} yanlış alarm, {km[1, 0]} kaçırılan çatlak")
assert dog_cnn > max(v[0] for v in temel.values())

# %% 6. Ağ neye bakıyor? Örtme (occlusion) duyarlılığı
# 2. bölümdeki derz + çatlak görüntüsü (eğitimde yok); maskeleri biliniyor
ornek_o = ornek.astype(np.float32)
x0 = torch.tensor((ornek_o - ort) / std)[None, None]
bulanik = torch.tensor((gaussian_filter(ornek_o, 3.0) - ort) / std)   # ince çizgileri silen yumuşak dolgu
boy, kayma = 8, 4
konum = list(range(0, N - boy + 1, kayma))
ortulu, yama_catlak, yama_derz = [], [], []
for i in konum:
    for j in konum:
        x = x0.clone()
        x[0, 0, i:i + boy, j:j + boy] = bulanik[i:i + boy, j:j + boy]   # yamayı bulanık hâliyle ört
        ortulu.append(x)
        yama_catlak.append(maske_catlak[i:i + boy, j:j + boy].any())
        yama_derz.append(maske_derz[i:i + boy, j:j + boy].any())
with torch.no_grad():
    z0 = model(x0).item()
    z_ort = model(torch.cat(ortulu)).numpy()
dusus = (z0 - z_ort).reshape(len(konum), len(konum))       # logit düşüşü: büyükse o yama önemli
yc, yd_ = np.array(yama_catlak), np.array(yama_derz) & ~np.array(yama_catlak)
print("\n=== 6. Örtme duyarlılığı (2. bölümdeki derz + çatlak görüntüsü) ===")
print(f"p = {1 / (1 + np.exp(-z0)):.3f} (logit {z0:.2f}); 8×8 yama bulanıklaştırılınca ortalama logit düşüşü: "
      f"çatlağa değen {yc.sum()} yamada {(z0 - z_ort)[yc].mean():.2f}, yalnız derze değen {yd_.sum()} yamada "
      f"{(z0 - z_ort)[yd_].mean():.2f}, diğer {(~yc & ~yd_).sum()} yamada {(z0 - z_ort)[~yc & ~yd_].mean():.2f}")
W1 = model.govde[0].weight.detach().numpy()[:, 0]              # (8, 3, 3) birinci katman filtreleri
print("1. katman filtrelerinde Σw/Σ|w| (0'a yakınsa fark, ±1'e yakınsa ortalama parlaklık algılayıcı): "
      + ", ".join(f"{w.sum() / np.abs(w).sum():+.2f}" for w in W1))

# Kontrollü sınama: aynı dokuya derz ekleyip çıkarmak (örtme haritasının söyleyemediğini sınar)
rng_k = np.random.default_rng(5)
ciftler = []
for _ in range(600):
    t0 = doku(rng_k)
    cl = catlak(np.zeros((N, N)), rng_k)                        # yalnız çatlak katmanı (koyulaştırma)
    dl = derz(np.zeros((N, N)), rng_k)                          # yalnız derz katmanı
    ciftler += [t0 + cl, t0 + cl + dl, t0, t0 + dl]
Xk = np.clip(np.stack(ciftler), 0, 1).astype(np.float32)
with torch.no_grad():
    zk = model(torch.tensor((Xk - ort) / std)[:, None]).numpy().reshape(-1, 4)
print(f"Kontrollü sınama, 600 doku: çatlaklıda 'çatlak' kararı derzsiz %{100*np.mean(zk[:, 0] > 0):.1f}, "
      f"derzli %{100*np.mean(zk[:, 1] > 0):.1f} "
      f"(derz eklemenin logit etkisi medyanı {np.median(zk[:, 1] - zk[:, 0]):+.2f}); "
      f"çatlaksızda yanlış alarm derzsiz %{100*np.mean(zk[:, 2] > 0):.1f}, derzli %{100*np.mean(zk[:, 3] > 0):.1f}")

# %% 7. Grafikler
fig, ax = plt.subplots(1, 4, figsize=(10, 3.1), layout="constrained")
s = np.abs(Gx).max()
paneller = [(ornek, "Görüntü", "gray", (0, 1)), (Gx, "Gx (yatay türev)", "RdBu_r", (-s, s)),
            (Gy, "Gy (düşey türev)", "RdBu_r", (-s, s)),
            (Gbuyukluk, "|G| (kenar şiddeti)", "Blues", (0, Gbuyukluk.max()))]
for a, (img, baslik, cmap, sinir) in zip(ax, paneller):
    a.imshow(img, cmap=cmap, vmin=sinir[0], vmax=sinir[1], interpolation="nearest")
    a.set_title(baslik, fontsize=10)
    a.set_xticks([]), a.set_yticks([])
    a.grid(False)
fig.savefig(KLASOR / "d13_cnn_catlak_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
d = np.arange(1, DONEM + 1)
ax[0].plot(d, gecmis["egitim"], color=RENK[0], label="Eğitim kaybı (artırılmış veri)")
ax[0].plot(d, gecmis["dogrulama"], color=RENK[1], label="Doğrulama kaybı")
ax[0].set(xlabel="Dönem", ylabel="İkili çapraz entropi", title="Eğitim eğrileri", xticks=d)
ax[0].legend(loc="upper right")
ax[1].imshow(km, cmap="Blues")
for (i, j), v in np.ndenumerate(km):
    ax[1].text(j, i, str(v), ha="center", va="center", fontsize=14,
               color="white" if v > km.max() / 2 else MUREKKEP)
ax[1].set(xticks=[0, 1], yticks=[0, 1], xticklabels=["sağlam", "çatlak"], yticklabels=["sağlam", "çatlak"],
          xlabel="Tahmin", ylabel="Gerçek", title=f"Test karışıklık matrisi (doğruluk %{100*dog_cnn:.1f})")
ax[1].grid(False)
fig.savefig(KLASOR / "d13_cnn_catlak_2.png", dpi=160)
plt.close(fig)

secim = list(yanlis[:8])
dogrular = np.flatnonzero(tahmin == y_test)
secim += list(np.random.default_rng(0).choice(dogrular, 24 - len(secim), replace=False))
secim = sorted(secim)
fig, axs = plt.subplots(3, 8, figsize=(10, 4.6), layout="constrained")
for a, i in zip(axs.ravel(), secim):
    a.imshow(X_tum[te][i], cmap="gray", vmin=0, vmax=1, interpolation="nearest")
    hata = tahmin[i] != y_test[i]
    a.set_title(f"{'çatlak' if y_test[i] else 'sağlam'} · p={p_test[i]:.2f}", fontsize=7.5,
                color=RENK[1] if hata else MUREKKEP, fontweight="bold" if hata else "normal")
    if hata:
        for kenar in a.spines.values():
            kenar.set_visible(True); kenar.set_color(RENK[1]); kenar.set_linewidth(2.5)
    a.set_xticks([]), a.set_yticks([])
    a.grid(False)
fig.savefig(KLASOR / "d13_cnn_catlak_3.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 3, figsize=(10, 3.6), layout="constrained")
mozaik = np.full((2 * 4 - 1, 4 * 4 - 1), np.nan)
for k in range(len(W1)):
    r, c = divmod(k, 4)
    mozaik[r * 4:r * 4 + 3, c * 4:c * 4 + 3] = W1[k] / np.abs(W1[k]).max()
ax[0].imshow(mozaik, cmap="RdBu_r", vmin=-1, vmax=1, interpolation="nearest")
ax[0].set_title("1. katmanın 8 filtresi (3×3)", fontsize=10)
ax[1].imshow(ornek_o, cmap="gray", vmin=0, vmax=1, interpolation="nearest")
ax[1].set_title(f"Derz + çatlak (p = {1 / (1 + np.exp(-z0)):.2f})", fontsize=10)
s = np.abs(dusus).max()
merkez = np.array(konum) + boy / 2
alt_s, ust_s = merkez[0] - kayma / 2, merkez[-1] + kayma / 2      # haritanın piksel sınırları
im = ax[2].imshow(dusus, cmap="RdBu_r", vmin=-s, vmax=s, interpolation="nearest",
                  extent=(alt_s, ust_s, ust_s, alt_s))
ax[2].contour(maske_catlak.astype(float), levels=[0.5], colors=MUREKKEP, linewidths=0.8)
ax[2].set(xlim=(alt_s, ust_s), ylim=(ust_s, alt_s))
ax[2].set_title("Örtülünce logit düşüşü", fontsize=10)
fig.colorbar(im, ax=ax[2], shrink=0.8)
for a in ax:
    a.set_xticks([]), a.set_yticks([])
    a.grid(False)
fig.savefig(KLASOR / "d13_cnn_catlak_4.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d13_cnn_catlak_1.png, _2.png, _3.png, _4.png")
