#!/usr/bin/env python3
"""Demo 1 — geri yayılımı sıfırdan (yalnız numpy) yazıp XOR'u öğretmek.

Kurgu Rumelhart-Hinton-Williams (Nature 1986) denklemlerini izler:
  x_j = sum_i y_i w_ji (+ bias),  y_j = 1/(1+e^-x_j),  E = 1/2 sum (y - d)^2
  geri geçiş: dE/dy = y - d ; dE/dx = dE/dy * y(1-y) ; dE/dw_ji = dE/dx_j * y_i
Güncelleme: makaledeki gibi tüm örnekler üzerinden toplanan gradyan + momentum (eps, alpha).

Çıktı: demo/xor-sonuc.json (kayıp eğrisi, son çıktılar, ağırlıklar, 100 tohum istatistiği,
       ayrıca gizli katmansız ağın aynı işteki kaybı).
"""
import json, os, time, platform
import numpy as np

H = os.path.dirname(os.path.abspath(__file__))
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], float)
D = np.array([[0], [1], [1], [0]], float)
sig = lambda x: 1 / (1 + np.exp(-x))


def train(seed, hidden=2, eps=0.5, alpha=0.9, sweeps=5000, init=1.0, log_every=10):
    rng = np.random.default_rng(seed)
    if hidden:
        W1 = rng.uniform(-init, init, (2, hidden)); b1 = rng.uniform(-init, init, hidden)
        W2 = rng.uniform(-init, init, (hidden, 1)); b2 = rng.uniform(-init, init, 1)
        P = [W1, b1, W2, b2]
    else:
        W2 = rng.uniform(-init, init, (2, 1)); b2 = rng.uniform(-init, init, 1)
        P = [W2, b2]
    V = [np.zeros_like(p) for p in P]
    curve = []
    for s in range(sweeps + 1):
        # ileri geçiş
        if hidden:
            h = sig(X @ P[0] + P[1]); y = sig(h @ P[2] + P[3])
        else:
            y = sig(X @ P[0] + P[1])
        E = 0.5 * float(((y - D) ** 2).sum())
        if s % log_every == 0:
            curve.append([s, round(E, 6)])
        if s == sweeps:
            break
        # geri geçiş (zincir kuralı, elle)
        dy = y - D
        dx2 = dy * y * (1 - y)
        if hidden:
            gW2 = h.T @ dx2; gb2 = dx2.sum(0)
            dh = dx2 @ P[2].T
            dx1 = dh * h * (1 - h)
            gW1 = X.T @ dx1; gb1 = dx1.sum(0)
            G = [gW1, gb1, gW2, gb2]
        else:
            G = [X.T @ dx2, dx2.sum(0)]
        for k in range(len(P)):
            V[k] = -eps * G[k] + alpha * V[k]
            P[k] += V[k]
    out = {'seed': seed, 'hidden': hidden, 'final_E': round(E, 6), 'outputs': [round(float(v), 4) for v in y.ravel()],
           'curve': curve}
    if hidden:
        out['weights'] = {'W1': np.round(P[0], 3).tolist(), 'b1': np.round(P[1], 3).tolist(),
                          'W2': np.round(P[2], 3).ravel().tolist(), 'b2': np.round(P[3], 3).tolist()}
        out['hidden_activations'] = np.round(sig(X @ P[0] + P[1]), 3).tolist()
    return out


if __name__ == '__main__':
    t0 = time.perf_counter()
    first_try = train(seed=1)  # ilk denediğim tohum (seçilmedi; 1'den başladım)
    # 1'den sonra çözen ilk tohum (atlananlar kayıtta)
    sd, skipped = 2, []
    while True:
        main = train(seed=sd)
        if main['final_E'] < 0.1:
            break
        skipped.append(sd); sd += 1
    flat = train(seed=1, hidden=0)
    # Kaç başlangıçta takılıyor? 100 tohum, "çözdü" = 4 çıktının hepsi doğru tarafta ve hata < 0.1
    stats = []
    for sd in range(100):
        r = train(seed=sd, log_every=5000)
        ok = all((o > 0.5) == bool(d) for o, d in zip(r['outputs'], D.ravel())) and r['final_E'] < 0.1
        stats.append({'seed': sd, 'final_E': r['final_E'], 'solved': ok})
    # Çözüme hangi turda ulaştı (E < 0.05 ilk kez)
    first = next((s for s, e in main['curve'] if e < 0.05), None)
    res = {
        'aciklama': 'numpy ile elle yazılmış geri yayılım, 2-2-1 sigmoid ağ, XOR, tam yığın gradyan + momentum (Nature 1986 denklemleri)',
        'hiperparametre': {'eps': 0.5, 'alpha': 0.9, 'sweeps': 5000, 'init': 'U(-1,1)', 'hata': 'E = 1/2 * toplam (y-d)^2'},
        'ilk_deneme_tohum1': first_try,
        'ana_kosu': main, 'ana_kosu_secimi': '1. tohumdan sonra hata<0.1 olan ilk tohum', 'atlanan_tohumlar': skipped,
        'E_0.05_alti_ilk_tur': first,
        'gizli_katmansiz': flat,
        'tohum_100': {'cozen': sum(s['solved'] for s in stats), 'takilan': [s for s in stats if not s['solved']],
                      'hepsi': stats},
        'sure_sn': round(time.perf_counter() - t0, 3),
        'ortam': {'python': platform.python_version(), 'numpy': np.__version__, 'cpu': platform.processor() or platform.machine()},
    }
    json.dump(res, open(os.path.join(H, 'xor-sonuc.json'), 'w'), ensure_ascii=False, indent=1)
    print('ilk deneme (tohum 1): E', first_try['final_E'], first_try['outputs'])
    print('ana tohum', main['seed'], 'atlanan', skipped)
    print('ana: E', main['final_E'], 'çıktılar', main['outputs'], 'E<0.05 ilk tur', first)
    print('gizli katmansız: E', flat['final_E'], flat['outputs'])
    print('100 tohumda çözen', res['tohum_100']['cozen'], 'süre', res['sure_sn'])
