#!/usr/bin/env python3
"""Demo 2 — LeNet-5 benzeri evrişimli ağı MNIST'te eğitmek (PyTorch, GPU2 RTX 5090).

LeNet-5'e (LeCun vd. 1998) yakın: 32x32 giriş (28x28 + 2 piksel dolgu), C1 6@5x5, S2 ortalama havuz,
C3 16@5x5, S4 ortalama havuz, C5 120, F6 84, 10 çıkış, tanh. Farklar (dürüstçe): C3'teki seyrek bağlantı
tablosu yerine tam bağlantı, RBF çıkış yerine düz doğrusal katman + çapraz entropi, makaledeki diyagonal
Levenberg-Marquardt yerine Adam. Makaledeki gibi 20 tur.

Kullanım: CUDA_DEVICE_ORDER=PCI_BUS_ID CUDA_VISIBLE_DEVICES=2 python lenet_mnist.py [--cpu-epoch]
Çıktı: demo/lenet-sonuc.json, demo/lenet5.pt, demo/lenet-hatalar.npz
"""
import json, os, sys, time, hashlib, platform
import numpy as np
import torch, torch.nn as nn, torch.nn.functional as Fn
import torchvision
from torchvision import datasets, transforms

H = os.path.dirname(os.path.abspath(__file__))
DATA = os.path.join(H, 'data')
torch.manual_seed(0); np.random.seed(0)


class LeNet5(nn.Module):
    def __init__(self):
        super().__init__()
        self.c1 = nn.Conv2d(1, 6, 5, padding=2)    # 28x28 -> 28x28 (32x32 girişe eşdeğer)
        self.c3 = nn.Conv2d(6, 16, 5)               # 14x14 -> 10x10
        self.c5 = nn.Linear(16 * 5 * 5, 120)
        self.f6 = nn.Linear(120, 84)
        self.out = nn.Linear(84, 10)

    def forward(self, x, maps=False):
        a1 = torch.tanh(self.c1(x)); s2 = Fn.avg_pool2d(a1, 2)
        a3 = torch.tanh(self.c3(s2)); s4 = Fn.avg_pool2d(a3, 2)
        h = torch.tanh(self.c5(s4.flatten(1))); h = torch.tanh(self.f6(h))
        y = self.out(h)
        return (y, a1, a3) if maps else y


MEAN, STD = 0.1307, 0.3081
tf = transforms.Compose([transforms.ToTensor(), transforms.Normalize((MEAN,), (STD,))])


def md5(p):
    return hashlib.md5(open(p, 'rb').read()).hexdigest()


def evaluate(model, loader, dev):
    model.eval(); wrong = []; correct = 0; n = 0; probs_all = []
    with torch.no_grad():
        for i, (x, y) in enumerate(loader):
            x, y = x.to(dev), y.to(dev)
            p = Fn.softmax(model(x), 1); pr = p.argmax(1)
            correct += int((pr == y).sum()); n += len(y)
            probs_all.append(p.cpu())
    model.train()
    return correct / n, torch.cat(probs_all)


def run(dev, epochs, log_name):
    tr = datasets.MNIST(DATA, train=True, download=True, transform=tf)
    te = datasets.MNIST(DATA, train=False, download=True, transform=tf)
    pin = dev.type == 'cuda'
    trl = torch.utils.data.DataLoader(tr, batch_size=64, shuffle=True, num_workers=4, pin_memory=pin)
    tel = torch.utils.data.DataLoader(te, batch_size=1000, shuffle=False, num_workers=2, pin_memory=pin)
    model = LeNet5().to(dev)
    nparam = sum(p.numel() for p in model.parameters())
    opt = torch.optim.Adam(model.parameters(), lr=1e-3)
    sched = torch.optim.lr_scheduler.StepLR(opt, step_size=8, gamma=0.3)
    hist, loss_curve, step = [], [], 0
    if dev.type == 'cuda':
        torch.cuda.reset_peak_memory_stats(dev); torch.cuda.synchronize()
    t_all = time.perf_counter()
    first_hit = None
    for ep in range(1, epochs + 1):
        t0 = time.perf_counter(); run_loss = 0.0; k = 0
        for x, y in trl:
            x, y = x.to(dev, non_blocking=True), y.to(dev, non_blocking=True)
            loss = Fn.cross_entropy(model(x), y)
            opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
            run_loss += float(loss); k += 1; step += 1
            if step % 50 == 0:
                loss_curve.append([step, round(run_loss / k, 5)])
        sched.step()
        if dev.type == 'cuda':
            torch.cuda.synchronize()
        dt = time.perf_counter() - t0
        acc, _ = evaluate(model, tel, dev)
        hist.append({'tur': ep, 'sure_sn': round(dt, 2), 'egitim_kaybi': round(run_loss / k, 5), 'test_dogruluk': round(acc, 5),
                     'test_hata_yuzde': round(100 * (1 - acc), 2)})
        if first_hit is None and acc >= 0.99:
            first_hit = ep
        print(log_name, hist[-1], flush=True)
    total = time.perf_counter() - t_all
    peak = torch.cuda.max_memory_allocated(dev) / 2**20 if dev.type == 'cuda' else None
    return model, tr, te, tel, hist, loss_curve, total, peak, nparam, first_hit


if __name__ == '__main__':
    if '--cpu-epoch' in sys.argv:  # karşılaştırma: aynı ağ, 1 tur, CPU
        torch.set_num_threads(int(os.environ.get('THREADS', '16')))
        _, _, _, _, hist, _, total, _, nparam, _ = run(torch.device('cpu'), 1, 'cpu')
        json.dump({'cihaz': 'CPU ' + platform.processor(), 'torch_threads': torch.get_num_threads(), 'tur': hist, 'toplam_sn': round(total, 2)},
                  open(os.path.join(H, 'lenet-cpu-1tur.json'), 'w'), ensure_ascii=False, indent=1)
        sys.exit()
    dev = torch.device('cuda')
    model, tr, te, tel, hist, loss_curve, total, peak, nparam, first_hit = run(dev, 20, 'gpu')
    acc, probs = evaluate(model, tel, dev)
    labels = te.targets.numpy(); pred = probs.argmax(1).numpy()
    wrong = np.nonzero(pred != labels)[0]
    # hatalılar: en emin olunan yanlışlar önce
    conf = probs.max(1).values.numpy()
    wrong = wrong[np.argsort(-conf[wrong])]
    top2 = probs.topk(2, 1)
    werr = [{'indeks': int(i), 'dogru': int(labels[i]), 'tahmin': int(pred[i]), 'guven': round(float(conf[i]), 4),
             'ikinci': int(top2.indices[i, 1]), 'ikinci_olasilik': round(float(top2.values[i, 1]), 4),
             'dogru_sinif_olasilik': round(float(probs[i, labels[i]]), 4)} for i in wrong]
    raw = te.data.numpy()
    np.savez_compressed(os.path.join(H, 'lenet-hatalar.npz'), images=raw[wrong], idx=wrong, labels=labels[wrong], pred=pred[wrong])
    # karışıklık matrisi
    cm = np.zeros((10, 10), int)
    for a, b in zip(labels, pred):
        cm[a, b] += 1
    # ilk katman filtreleri ve bir örneğin özellik haritaları
    filt = model.c1.weight.detach().cpu().numpy()[:, 0]
    x0 = te[0][0].unsqueeze(0).to(dev)
    with torch.no_grad():
        _, a1, a3 = model(x0, maps=True)
    np.savez_compressed(os.path.join(H, 'lenet-haritalar.npz'), filters=filt, a1=a1[0].cpu().numpy(), a3=a3[0].cpu().numpy(),
                        img=raw[0], label=int(labels[0]))
    torch.save(model.state_dict(), os.path.join(H, 'lenet5.pt'))
    raw_files = sorted(os.listdir(os.path.join(DATA, 'MNIST', 'raw')))
    res = {
        'aciklama': 'LeNet-5 benzeri CNN, MNIST, 20 tur, PyTorch, tek RTX 5090 (GPU2)',
        'mimari': 'giriş 28x28(+2 dolgu=32x32) · C1 6@5x5 tanh · S2 ort.havuz · C3 16@5x5 tanh · S4 ort.havuz · C5 120 · F6 84 · 10',
        'lenet5_farklari': ['C3 tam bağlantılı (makalede seyrek tablo)', 'çıkış doğrusal+çapraz entropi (makalede RBF)',
                            'Adam lr 1e-3, 8 turda bir x0.3 (makalede diyagonal Levenberg-Marquardt)', 'veri artırma yok'],
        'parametre_sayisi': nparam, 'tur_sayisi': len(hist), 'turlar': hist,
        'toplam_egitim_sn': round(total, 2), 'tepe_gpu_bellek_mib': round(peak, 1),
        'ilk_yuzde99_tur': first_hit,
        'son_test_dogruluk': round(acc, 5), 'son_test_hata_sayisi': int(len(wrong)), 'test_ornek': int(len(labels)),
        'hatalar': werr, 'karisiklik': cm.tolist(), 'kayip_egrisi': loss_curve,
        'veri': {'kaynak': 'torchvision.datasets.MNIST (indirme aynası: ' + ', '.join(datasets.MNIST.mirrors) + ')',
                 'dosyalar': {f: md5(os.path.join(DATA, 'MNIST', 'raw', f)) for f in raw_files if not f.endswith('.gz')},
                 'egitim': len(tr), 'test': len(te)},
        'ortam': {'torch': torch.__version__, 'torchvision': torchvision.__version__, 'cuda': torch.version.cuda,
                  'gpu': torch.cuda.get_device_name(dev), 'python': platform.python_version(),
                  'CUDA_VISIBLE_DEVICES': os.environ.get('CUDA_VISIBLE_DEVICES')},
    }
    json.dump(res, open(os.path.join(H, 'lenet-sonuc.json'), 'w'), ensure_ascii=False, indent=1)
    print('bitti: doğruluk', acc, 'hata', len(wrong), 'süre', round(total, 1), 'sn, param', nparam, 'tepe MiB', round(peak, 1))
