#!/usr/bin/env python3
"""Yapay zekâ tarihi #2 — Perceptron demosu (numpy, sıfırdan, CPU).

1) 1958 gösterisinin yeniden kuruluşu: 20×20 'kart' (Mark I'in 20×20 fotosel retinası boyutunda),
   kartta solda ya da sağda içi dolu bir kare. Rosenblatt'ın hata düzeltme kuralı:
   cevap doğruysa hiçbir şey değişmez; yanlışsa ağırlıklar doğru cevap yönüne itilir.
   a) piksel perceptronu  : 400 giriş -> 1 çıkış (bugünkü ders kitabı biçimi)
   b) Mark I benzeri      : 400 S -> 512 A (rastgele, sabit, eşikli bağlantılar) -> 1 R (öğrenen)
   c) iki kart            : NYT'deki gibi yalnız iki kart (biri solda, biri sağda işaretli)
   Her biri 20 tohumla; 'öğrendi' = 1000 kartlık ayrı test setinde ilk kez %100 doğruluk.
2) XOR: tek perceptron 1000 tur (asla 4/4 olmaz, ağırlıklar döngüye girer); 2-2-1 ve 2-4-1 gizli katmanlı ağ
   (sigmoid + geri yayılım, numpy) 20 tohum.
Çıktılar demo/*.json (ham kayıt). Video ve anlatım yalnız bu dosyalardan okunur.
"""
import json, os, platform, sys, time
import numpy as np

D = os.path.dirname(os.path.abspath(__file__))
N = 20  # 20×20 retina
SEEDS = list(range(20))
MAXT = 3000
TH = (0.9, 0.95, 0.99)  # test doğruluğu eşikleri: ilk ulaşılan deneme


def card(rng, side=None):
    """side 0 = solda işaret (cevap -1), 1 = sağda işaret (cevap +1). Kare kenarı 3–6 piksel, yarının içinde rastgele yer."""
    if side is None:
        side = int(rng.integers(2))
    s = int(rng.integers(3, 7))
    x0 = int(rng.integers(0, N // 2 - s + 1)) + (N // 2 if side else 0)
    y0 = int(rng.integers(0, N - s + 1))
    im = np.zeros((N, N), np.int8); im[y0:y0 + s, x0:x0 + s] = 1
    return im, (1 if side else -1)


def testset(seed=999, n=1000):
    rng = np.random.default_rng(seed)
    X, Y = [], []
    for _ in range(n):
        im, y = card(rng); X.append(im.ravel()); Y.append(y)
    return np.array(X, np.int32), np.array(Y)


# ---------------- 1a: piksel perceptronu ----------------
def run_pixel(seed, XT, YT, record=False, stream=None):
    rng = np.random.default_rng(seed)
    w = np.zeros(N * N, np.int32); b = 0
    hist, learned, mistakes, rec, first_at, m_at, w_at, b_at = [], None, 0, [], {}, None, None, None
    for t in range(1, MAXT + 1):
        if stream is not None:
            im, y = stream[(t - 1) % len(stream)]
        else:
            im, y = card(rng)
        x = im.ravel().astype(np.int32)
        a = int(w @ x + b); pred = 1 if a > 0 else -1  # 0 -> 'sol' (karar verememe de yanlış sayılır)
        wrong = pred != y
        if wrong:
            w += y * x; b += y; mistakes += 1
        acc = float(np.mean(np.where(XT @ w + b > 0, 1, -1) == YT))
        hist.append(acc)
        if record and t <= 160:
            rec.append(dict(t=t, card=x.tolist(), y=y, pred=pred, wrong=bool(wrong), w=w.tolist(), b=b, test_acc=acc, mistakes=mistakes))
        for th in TH:
            if th not in first_at and acc >= th:
                first_at[th] = t
        if learned is None and acc == 1.0:
            learned = t; m_at = mistakes; w_at = w.tolist(); b_at = b
            if not record:
                break
    return dict(seed=seed, learned_at=learned, mistakes_until=m_at, mistakes_total_run=mistakes, trials_run=t, w_at_learned=w_at, b_at_learned=b_at,
                first_at={str(k): v for k, v in first_at.items()}, acc_first=hist[:200], w=w.tolist(), b=b), rec


# ---------------- 1b: Mark I benzeri (S -> A rastgele sabit -> R öğrenen) ----------------
NA, FAN, THR = 512, 10, 1  # her A biriminin 10 rastgele S bağlantısı (+1/-1), eşik: toplam >= 1


def make_A(seed):
    rng = np.random.default_rng(10_000 + seed)
    C = np.zeros((NA, N * N), np.int32)
    for a in range(NA):
        idx = rng.choice(N * N, FAN, replace=False)
        C[a, idx] = rng.choice([-1, 1], FAN)
    return C


def run_marki(seed, XT, YT):
    C = make_A(seed)
    AT = (XT @ C.T >= THR).astype(np.int32)
    rng = np.random.default_rng(seed)
    v = np.zeros(NA, np.int32); b = 0
    learned, mistakes, hist, first_at = None, 0, [], {}
    for t in range(1, MAXT + 1):
        im, y = card(rng)
        a = (C @ im.ravel().astype(np.int32) >= THR).astype(np.int32)
        pred = 1 if int(v @ a + b) > 0 else -1
        if pred != y:  # yalnız aktif A birimlerinin değeri doğru yöne değişir
            v += y * a; b += y; mistakes += 1
        acc = float(np.mean(np.where(AT @ v + b > 0, 1, -1) == YT)); hist.append(acc)
        for th in TH:
            if th not in first_at and acc >= th:
                first_at[th] = t
        if acc == 1.0:
            learned = t; break
    return dict(seed=seed, learned_at=learned, mistakes_until=mistakes, first_at={str(k): v for k, v in first_at.items()}, active_A_mean_test=float(AT.sum(1).mean()), acc_first=hist[:200])


# ---------------- 2: XOR ----------------
XX = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]); XY = np.array([0, 1, 1, 0])


def xor_single(epochs=1000):
    w = np.zeros(2, np.int32); b = 0; per_epoch = []
    states = []
    for e in range(epochs):
        err = 0
        for x, y in zip(XX, XY):
            yy = 1 if y else -1
            pred = 1 if int(w @ x + b) > 0 else -1
            if pred != yy:
                w += yy * x; b += yy; err += 1
        correct = int(sum((1 if int(w @ x + b) > 0 else 0) == y for x, y in zip(XX, XY)))
        per_epoch.append(dict(epoch=e + 1, updates=err, correct_after=correct, w=w.tolist(), b=b))
        states.append((tuple(w.tolist()), b))
    # döngü tespiti
    first = {}
    cyc = None
    for i, s in enumerate(states):
        if s in first:
            cyc = dict(state=list(s[0]) + [s[1]], first_epoch=first[s] + 1, repeat_epoch=i + 1, period=i - first[s]); break
        first[s] = i
    best = max(p['correct_after'] for p in per_epoch)
    return dict(epochs=epochs, max_correct=best, ever_4_of_4=best == 4, first_epochs=per_epoch[:12], last_epochs=per_epoch[-4:], cycle=cyc)


def sig(z):
    return 1 / (1 + np.exp(-z))


def xor_mlp(seed, hidden, epochs=20000, lr=0.5):
    rng = np.random.default_rng(seed)
    W1 = rng.normal(0, 1, (2, hidden)); b1 = np.zeros(hidden)
    W2 = rng.normal(0, 1, (hidden, 1)); b2 = np.zeros(1)
    X = XX.astype(float); Y = XY.reshape(-1, 1).astype(float)
    loss = []; solved_at = None
    for e in range(1, epochs + 1):
        h = sig(X @ W1 + b1); o = sig(h @ W2 + b2)
        L = float(np.mean((o - Y) ** 2))
        if e % 100 == 1 or e == epochs:
            loss.append([e, round(L, 6)])
        if solved_at is None and np.all((o > 0.5) == (Y > 0.5)):
            solved_at = e
        do = (o - Y) * o * (1 - o)
        dh = (do @ W2.T) * h * (1 - h)
        W2 -= lr * h.T @ do; b2 -= lr * do.sum(0)
        W1 -= lr * X.T @ dh; b1 -= lr * dh.sum(0)
    h = sig(X @ W1 + b1); o = sig(h @ W2 + b2).ravel()
    ok = bool(np.all((o > 0.5) == (XY > 0.5)))
    return dict(seed=seed, hidden=hidden, epochs=epochs, lr=lr, solved=ok, first_epoch_all_correct=solved_at,
                outputs=[round(float(v), 4) for v in o], final_mse=round(float(np.mean((o - XY) ** 2)), 6), loss=loss,
                W1=np.round(W1, 3).tolist(), b1=np.round(b1, 3).tolist(), W2=np.round(W2.ravel(), 3).tolist(), b2=round(float(b2[0]), 3))


def stats(v):
    v = [x for x in v if x is not None]
    if not v:
        return {}
    a = np.array(v)
    return dict(n=len(v), min=int(a.min()), median=float(np.median(a)), mean=round(float(a.mean()), 1), max=int(a.max()))


if __name__ == '__main__':
    t0 = time.time()
    XT, YT = testset()
    # 1a
    pix = []; live = None
    for s in SEEDS:
        r, rec = run_pixel(s, XT, YT, record=(s == 0))
        if s == 0:
            live = rec
        pix.append(r)
    # 1c iki kart (NYT: biri solda, biri sağda işaretli iki kart). Kartlar sabit tohumla; sırayla gösteriliyor.
    two = []
    for s in SEEDS:
        rng = np.random.default_rng(500 + s)
        cards = [card(rng, 0), card(rng, 1)]
        XT2 = np.array([c[0].ravel() for c in cards], np.int32); YT2 = np.array([c[1] for c in cards])
        r, _ = run_pixel(s, XT2, YT2, stream=cards)
        r['acc_on_1000_test_after'] = float(np.mean(np.where(XT @ np.array(r['w']) + r['b'] > 0, 1, -1) == YT))
        two.append({k: r[k] for k in ('seed', 'learned_at', 'mistakes_until', 'acc_on_1000_test_after')})
    # 1b
    mk = [run_marki(s, XT, YT) for s in SEEDS]
    res1 = dict(
        aciklama='20x20 kart, solda/sagda ici dolu kare (kenar 3-6 px). Ogrendi = 1000 kartlik ayri test setinde ilk kez %100.',
        test_n=len(YT), max_trials=MAXT,
        piksel=dict(model='400 giris -> 1 cikis, hata duzeltme kurali (yanlissa w += y*x, b += y), agirliklar 0dan',
                    ozet_learned_at=stats([p['learned_at'] for p in pix]), ozet_mistakes=stats([p['mistakes_until'] for p in pix]),
                    ozet_esik={str(th): stats([p['first_at'].get(str(th)) for p in pix]) for th in TH},
                    kosular=[{k: p[k] for k in ('seed', 'learned_at', 'mistakes_until', 'first_at')} for p in pix]),
        iki_kart=dict(model='ayni piksel perceptronu; yalniz iki sabit kart sirayla (NYT 1958 anlatimi gibi)',
                      ozet_learned_at=stats([p['learned_at'] for p in two]), kosular=two),
        mark1_benzeri=dict(model=f'400 S -> {NA} A (her A {FAN} rastgele S baglantisi, +1/-1, esik {THR}, sabit) -> 1 R; yanlista yalniz aktif A degerleri degisir',
                           ozet_learned_at=stats([p['learned_at'] for p in mk]), ozet_mistakes=stats([p['mistakes_until'] for p in mk]),
                           ozet_esik={str(th): stats([p['first_at'].get(str(th)) for p in mk]) for th in TH},
                           ogrenemeyen_3000de=[p['seed'] for p in mk if p['learned_at'] is None],
                           kosular=[{k: p[k] for k in ('seed', 'learned_at', 'mistakes_until', 'first_at', 'active_A_mean_test')} for p in mk]),
        sure_sn=round(time.time() - t0, 2))
    json.dump(res1, open(os.path.join(D, 'perceptron-kart.json'), 'w'), ensure_ascii=False, indent=1)
    json.dump(dict(seed=0, model='piksel perceptronu', test_n=len(YT), adimlar=live, learned_at=pix[0]['learned_at'], mistakes_until=pix[0]['mistakes_until'], w_at_learned=pix[0]['w_at_learned'], b_at_learned=pix[0]['b_at_learned'], son_w_t3000=pix[0]['w'], son_b_t3000=pix[0]['b'], mistakes_total_3000=pix[0]['mistakes_total_run'],
                   acc_egrisi=pix[0]['acc_first']), open(os.path.join(D, 'canli-seed0.json'), 'w'))
    json.dump(dict(piksel=[dict(seed=p['seed'], acc=p['acc_first']) for p in pix], mark1=[dict(seed=p['seed'], acc=p['acc_first']) for p in mk]),
              open(os.path.join(D, 'egriler.json'), 'w'))
    # 2
    t1 = time.time()
    xs = xor_single()
    m2 = [xor_mlp(s, 2) for s in SEEDS]; m4 = [xor_mlp(s, 4) for s in SEEDS]
    res2 = dict(tek_perceptron=xs,
                gizli_2=dict(model='2-2-1 sigmoid, geri yayilim, lr 0.5, 20000 tur', cozen=sum(r['solved'] for r in m2), toplam=len(m2),
                             ozet_ilk_dogru_tur=stats([r['first_epoch_all_correct'] for r in m2 if r['solved']]), kosular=m2),
                gizli_4=dict(model='2-4-1 sigmoid, geri yayilim, lr 0.5, 20000 tur', cozen=sum(r['solved'] for r in m4), toplam=len(m4),
                             ozet_ilk_dogru_tur=stats([r['first_epoch_all_correct'] for r in m4 if r['solved']]), kosular=m4),
                sure_sn=round(time.time() - t1, 2))
    json.dump(res2, open(os.path.join(D, 'xor.json'), 'w'), ensure_ascii=False, indent=1)
    json.dump(dict(python=sys.version, numpy=np.__version__, platform=platform.platform(), cpu=platform.processor() or platform.machine(),
                   komut=' '.join(sys.argv), tarih=time.strftime('%Y-%m-%dT%H:%M:%S%z'), gpu='kullanilmadi (yalniz CPU, numpy)'),
              open(os.path.join(D, 'ORTAM.json'), 'w'), ensure_ascii=False, indent=1)
    print(json.dumps({k: v for k, v in res1.items() if k in ('sure_sn',)}, ensure_ascii=False))
    for k in ('piksel', 'iki_kart', 'mark1_benzeri'):
        print(k, res1[k]['ozet_learned_at'], res1[k].get('ozet_mistakes'), res1[k].get('ozet_esik'))
    print('xor tek:', xs['max_correct'], xs['cycle'])
    print('2-2-1', res2['gizli_2']['cozen'], '/20', res2['gizli_2']['ozet_ilk_dogru_tur'])
    print('2-4-1', res2['gizli_4']['cozen'], '/20', res2['gizli_4']['ozet_ilk_dogru_tur'])
