Update app.py

app.py

@@ -1,5 +1,31 @@
-import numpy as np
-import time, collections, threading, json, random, math, os, pathlib
+"""
+main.py  v5  —  Scalar Triangulated Hourglass Mesh
+
+TOPOLOGY  (for n input dimensions, 9 rows):
+
+  A0 … An-1          row 0   width n      ← anchored inputs
+  ·  ·  ·  ·         row 1   width n+1
+  ·  ·  ·  ·  ·      row 2   width n+2    ← widest upper bulge
+  ·  ·  ·  ·         row 3   width n+1
+  C0 … Cn-1          row 4   width n      ← output waist
+  ·  ·  ·  ·         row 5   width n+1
+  ·  ·  ·  ·  ·      row 6   width n+2    ← widest lower bulge
+  ·  ·  ·  ·         row 7   width n+1
+  B0 … Bn-1          row 8   width n      ← anchored inputs
+
+Between any two adjacent rows the width changes by exactly ±1,
+producing a perfectly triangulated grid (no irregular fans).
+
+LEARNING (LMS):
+  Training : C anchored → settle hidden → backprop error → update inter-row K
+  Inference: C free    → settle to equilibrium → optionally update K via EWC
+
+INFERENCE K-UPDATE:
+  On each new problem the mesh adapts its springs in real-time with a smaller
+  learning rate, protected by the EWC Fisher diagonal so past knowledge is not lost.
+"""
+
+import numpy as np, time, collections, threading, json, random
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
@@ -7,299 +33,551 @@ from fastapi.middleware.cors import CORSMiddleware
 app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
-DIM = 8
-LR = 0.02        # Slower, highly stable learning rate
-EWC_LAMBDA = 0.8
-FISHER_DECAY = 0.95
-DAMPING = 0.6    # Increased damping for visual stability
-DT = 0.2
-
-# --- AUTO DATA GENERATOR ---
-def ensure_data():
-    out = pathlib.Path('data')
-    out.mkdir(exist_ok=True)
-    if os.path.exists('data/train.json') and os.path.exists('data/test.json'):
-        return
-    
-    print("Generating N-Dim Dataset...")
-    rng = np.random.default_rng(42)
-    data = []
-    for _ in range(1000):
-        a, b = rng.uniform(0.1, 0.9, DIM), rng.uniform(0.1, 0.9, DIM)
-        data.append({'a': a.tolist(), 'b': b.tolist(), 'c': (0.7 * a + 0.3 * b).tolist(), 'type': 'blend'})
-        data.append({'a': a.tolist(), 'b': b.tolist(), 'c': (0.5 + 0.4 * (a - b)).tolist(), 'type': 'diff'})
-        data.append({'a': a.tolist(), 'b': b.tolist(), 'c': (0.5 * np.roll(a, 1) + 0.5 * np.roll(b, -1)).tolist(), 'type': 'route'})
-    
-    random.shuffle(data)
-    split = int(len(data) * 0.9)
-    with open('data/train.json', 'w') as f: json.dump(data[:split], f)
-    with open('data/test.json', 'w') as f: json.dump(data[split:], f)
-
-ensure_data()
-# ---------------------------
-
-class PristineMesh:
-    def __init__(self, n_dim=DIM):
-        self.n_dim = n_dim
-        self.nodes = {}
-        self.springs = {}
-        self.fisher = {}
-        self.anchor_k = {}
-        self._build_lattice()
-
-    def _build_lattice(self):
-        self.row_widths = [
-            self.n_dim, self.n_dim+1, self.n_dim+2, self.n_dim+1, 
-            self.n_dim, 
-            self.n_dim+1, self.n_dim+2, self.n_dim+1, self.n_dim
-        ]
-        y_spacing = 0.866
-        
-        for r, w in enumerate(self.row_widths):
-            y = -r * y_spacing
-            x_offset = -(w - 1) / 2.0
-            
-            kind = 'H'
-            if r == 0: kind = 'A'
-            elif r == len(self.row_widths)-1: kind = 'B'
-            elif r == len(self.row_widths)//2: kind = 'C'
-            
-            for c in range(w):
-                nid = f"{kind}_r{r}_c{c}"
+# ── CONSTANTS ─────────────────────────────────────────────────────────────────
+DT      = 0.08
+DAMP    = 0.62
+GND     = 0.012    # soft restore toward 0.5 (keeps display bounded)
+SETTLE  = 80       # physics steps per CHL/display phase
+CONV    = 0.025    # |error| < this → converged
+MAXS    = 500      # hard cap per sample
+LR      = 0.018    # training learning rate
+LR_I    = 0.004    # inference K update rate (smaller → conservative)
+KCLIP   = 12.0
+EWC_L   = 0.8      # EWC penalty strength
+FD      = 0.95     # Fisher EMA decay
+MICRO   = 6        # display physics steps per server tick
+
+
+# ── MESH ──────────────────────────────────────────────────────────────────────
+
+def _widths(n):
+    return [n, n+1, n+2, n+1, n, n+1, n+2, n+1, n]
+
+def _xpos(w):
+    """Half-integer node positions for a row of width w.
+    Produces x ∈ {-(w-1)/2, ..., (w-1)/2} with step 1.
+    Adjacent rows interleave perfectly → clean triangulation."""
+    return [(2*i - (w-1)) / 2.0 for i in range(w)]
+
+
+class Mesh:
+    def __init__(self, n=1):
+        self.n = n
+        self._build()
+
+    # ── TOPOLOGY ──────────────────────────────────────────────────────────────
+
+    def _build(self):
+        n   = self.n
+        W   = _widths(n)
+        NR  = len(W)        # 9
+        NK  = 4             # neck row = C nodes
+
+        self.W = W; self.NR = NR; self.NK = NK
+
+        self.nodes  = {}    # id → attrs
+        self.layers = []    # list of rows; each row = list of node ids
+
+        for ri, w in enumerate(W):
+            kind = 'A' if ri==0 else 'B' if ri==NR-1 else 'C' if ri==NK else 'H'
+            xs = _xpos(w)
+            y  = 1.0 - 2.0*ri/(NR-1)
+            row = []
+            for ci in range(w):
+                nid = f"{ri}_{ci}"
                 self.nodes[nid] = {
-                    'x': 0.0, 'vel': 0.0, 'kind': kind, 'row': r, 'col': c,
-                    'pos': (x_offset + c, y), 'anchored': kind in ['A', 'B']
+                    'x':0.5, 'vel':0.0,
+                    'anchored': kind in ('A','B'),
+                    'row':ri, 'col':ci, 'kind':kind,
+                    'px':float(xs[ci]), 'py':float(y),
                 }
+                row.append(nid)
+            self.layers.append(row)
+
+        self.A = self.layers[0]
+        self.C = self.layers[NK]
+        self.B = self.layers[-1]
+
+        # Springs ─────────────────────────────────────────────────────────────
+        self.K     = {}                     # (u,v) → float  (u<v lex)
+        self.adj   = {nid:[] for nid in self.nodes}
+        self.vert  = set()                  # inter-row spring keys (learned)
+        self.horiz = set()                  # same-row spring keys (lateral flow)
+
+        for ri in range(NR):
+            row = self.layers[ri]
+            # Horizontal
+            for ci in range(len(row)-1):
+                k = self._add(row[ci], row[ci+1])
+                self.horiz.add(k)
+            # Inter-row  (width changes by exactly ±1)
+            if ri < NR-1:
+                up, dn = self.layers[ri], self.layers[ri+1]
+                wu, wd = len(up), len(dn)
+                if wd == wu+1:          # expanding: up[i]→dn[i], up[i]→dn[i+1]
+                    for i in range(wu):
+                        self.vert.add(self._add(up[i], dn[i]))
+                        self.vert.add(self._add(up[i], dn[i+1]))
+                elif wd == wu-1:        # contracting: up[i]→dn[i], up[i+1]→dn[i]
+                    for i in range(wd):
+                        self.vert.add(self._add(up[i],   dn[i]))
+                        self.vert.add(self._add(up[i+1], dn[i]))
+                else:                   # same width (unused in our topology)
+                    for i in range(min(wu,wd)):
+                        self.vert.add(self._add(up[i], dn[i]))
+
+        # Init springs to small positive values
+        for k in self.K: self.K[k] = random.uniform(0.20, 0.50)
+
+        # EWC state
+        self.fisher = {k: 0.0 for k in self.K}
+        self.K0     = dict(self.K)          # anchor for EWC
+
+        # Triangles (precomputed for visualisation)
+        self.tris = self._find_tris()
+
+    def _ek(self, a, b): return (a,b) if a<b else (b,a)
+
+    def _add(self, a, b):
+        k = self._ek(a,b)
+        if k not in self.K:
+            self.K[k] = 0.35
+            self.adj[a].append(b)
+            self.adj[b].append(a)
+        return k
+
+    def _find_tris(self):
+        as_ = {n: set(ns) for n, ns in self.adj.items()}
+        seen, tris = set(), []
+        for u, v in self.K:
+            for w in as_[u] & as_[v]:
+                key = tuple(sorted([u,v,w]))
+                if key not in seen:
+                    tris.append(key); seen.add(key)
+        return tris
+
+    # ── FORWARD PASS (layer-by-layer, LMS backbone) ───────────────────────────
+
+    def _fwd(self, a_vals, b_vals):
+        """
+        Signed weighted-average forward pass.
+
+        x[v] = Σ K_uv * x[u]  /  (Σ|K_uv| + ε)
+
+        Uses signed K so negative springs CAN pull output away from a neighbor
+        (needed for the 'diff' dataset).  Output clamped to [-0.5, 1.5] for safety.
+        """
+        x = {}
+        for i, nid in enumerate(self.A): x[nid] = float(a_vals[min(i, len(a_vals)-1)])
+        for i, nid in enumerate(self.B): x[nid] = float(b_vals[min(i, len(b_vals)-1)])
+
+        def _agg(nid, upstream_rows):
+            nb = [n for n in self.adj[nid]
+                  if self.nodes[n]['row'] in upstream_rows
+                  and self._ek(nid,n) in self.vert]
+            if not nb: return 0.5
+            ws  = [self.K[self._ek(nid,n)] for n in nb]
+            wab = sum(abs(w) for w in ws) + 1e-8
+            val = sum(w*x.get(n, 0.5) for w,n in zip(ws,nb)) / wab
+            return max(-0.5, min(1.5, val))
+
+        # Upper: rows 1→2→3→4(C)
+        for ri in range(1, self.NK+1):
+            for nid in self.layers[ri]:
+                if self.nodes[nid]['kind'] in ('A','B'): continue
+                x[nid] = _agg(nid, set(range(ri)))
+
+        # Lower: rows 7→6→5, then contributes into C (row 4)
+        for ri in range(self.NR-2, self.NK, -1):
+            for nid in self.layers[ri]:
+                if self.nodes[nid]['kind'] in ('A','B'): continue
+                x[nid] = _agg(nid, set(range(ri+1, self.NR)))
+
+        # C aggregates from row NK-1 (upper) AND row NK+1 (lower)
+        for nid in self.C:
+            nb = [n for n in self.adj[nid] if self._ek(nid,n) in self.vert]
+            ws  = [self.K[self._ek(nid,n)] for n in nb]
+            wab = sum(abs(w) for w in ws) + 1e-8
+            x[nid] = max(-0.5, min(1.5,
+                         sum(w*x.get(n,0.5) for w,n in zip(ws,nb)) / wab))
+
+        return x
+
+    # ── LMS UPDATE ────────────────────────────────────────────────────────────
+
+    def lms_update(self, a_vals, b_vals, c_target, ewc=False):
+        """
+        1. Run forward pass.
+        2. Compute error at C.
+        3. Backprop delta signal through vertical springs only (horizontal = lateral flow, not learned here).
+        4. Update each inter-row spring via Widrow-Hoff rule with optimal step size.
+        5. Accumulate Fisher diagonal for EWC.
+        """
+        x = self._fwd(a_vals, b_vals)
+
+        ct = [float(c_target[min(i, len(c_target)-1)]) for i in range(self.n)]
+        errs = [x[nid] - ct[i] for i, nid in enumerate(self.C)]
+        total_e = float(np.sqrt(sum(e**2 for e in errs)))
+
+        # ── Backprop deltas ───────────────────────────────────────────────────
+        delta = {nid: 0.0 for nid in self.nodes}
+        for i, nid in enumerate(self.C): delta[nid] = errs[i]
+
+        def _prop_up(ri):
+            """Propagate delta from row ri+1 back into row ri."""
+            for nid in self.layers[ri]:
+                dn_nb = [n for n in self.adj[nid]
+                         if self.nodes[n]['row'] == ri+1
+                         and self._ek(nid,n) in self.vert]
+                for nb in dn_nb:
+                    # How much does K(nid,nb) contribute to nb's total weight?
+                    up_of_nb = [n2 for n2 in self.adj[nb]
+                                if self.nodes[n2]['row'] < self.nodes[nb]['row']
+                                and self._ek(nb,n2) in self.vert]
+                    w_self = abs(self.K[self._ek(nid,nb)])
+                    w_sum  = sum(abs(self.K[self._ek(nb,n2)]) for n2 in up_of_nb) + 1e-8
+                    delta[nid] += delta[nb] * w_self / w_sum
+
+        def _prop_dn(ri):
+            """Propagate delta from row ri-1 back into row ri (lower half)."""
+            for nid in self.layers[ri]:
+                up_nb = [n for n in self.adj[nid]
+                         if self.nodes[n]['row'] == ri-1
+                         and self._ek(nid,n) in self.vert]
+                for nb in up_nb:
+                    dn_of_nb = [n2 for n2 in self.adj[nb]
+                                if self.nodes[n2]['row'] > self.nodes[nb]['row']
+                                and self._ek(nb,n2) in self.vert]
+                    w_self = abs(self.K[self._ek(nid,nb)])
+                    w_sum  = sum(abs(self.K[self._ek(nb,n2)]) for n2 in dn_of_nb) + 1e-8
+                    delta[nid] += delta[nb] * w_self / w_sum
+
+        for ri in range(self.NK-1, -1, -1):   _prop_up(ri)
+        for ri in range(self.NK+1, self.NR):   _prop_dn(ri)
+
+        # ── Widrow-Hoff update on inter-row springs ───────────────────────────
+        eps = 1e-8
+        for (u,v) in self.vert:
+            ru, rv = self.nodes[u]['row'], self.nodes[v]['row']
+            up_, dn_ = (u,v) if ru<rv else (v,u)
+            x_up = x.get(up_, 0.5)
+            d_dn = delta[dn_]
+            grad = d_dn * x_up
+            lr   = LR_I / (1.0 + EWC_L * self.fisher[(u,v)]) if ewc else LR
+            new_k = self.K[(u,v)] - lr * grad / (x_up**2 + eps)
+            self.K[(u,v)] = max(-KCLIP, min(KCLIP, new_k))
+            # Fisher
+            g2 = (grad / (x_up**2 + eps))**2
+            self.fisher[(u,v)] = FD*self.fisher[(u,v)] + (1-FD)*g2
+
+        return total_e, [round(x[nid], 4) for nid in self.C]
 
-        node_ids = list(self.nodes.keys())
-        for i in range(len(node_ids)):
-            for j in range(i + 1, len(node_ids)):
-                n1, n2 = node_ids[i], node_ids[j]
-                p1, p2 = self.nodes[n1]['pos'], self.nodes[n2]['pos']
-                if math.hypot(p1[0]-p2[0], p1[1]-p2[1]) < 1.05:
-                    key = tuple(sorted([n1, n2]))
-                    self.springs[key] = random.uniform(0.1, 0.4)
-                    self.fisher[key] = 0.0
-                    self.anchor_k[key] = self.springs[key]
-                    
-        self.c_nodes = sorted([n for n in self.nodes if self.nodes[n]['kind'] == 'C'], key=lambda k: self.nodes[k]['col'])
-        self.a_nodes = sorted([n for n in self.nodes if self.nodes[n]['kind'] == 'A'], key=lambda k: self.nodes[k]['col'])
-        self.b_nodes = sorted([n for n in self.nodes if self.nodes[n]['kind'] == 'B'], key=lambda k: self.nodes[k]['col'])
-
-    def set_inputs(self, a_vec, b_vec):
-        for i, nid in enumerate(self.a_nodes): self.nodes[nid]['x'] = a_vec[i]
-        for i, nid in enumerate(self.b_nodes): self.nodes[nid]['x'] = b_vec[i]
-        for nid, data in self.nodes.items():
-            if data['kind'] not in ['A', 'B']:
-                data['x'] = 0.0
-                data['vel'] = 0.0
-
-    def settle(self, steps=30):
-        for _ in range(steps):
-            forces = {n: 0.0 for n in self.nodes}
-            for (u, v), K in self.springs.items():
+    # ── HOOKE DISPLAY PHYSICS ─────────────────────────────────────────────────
+
+    def set_inputs(self, a_vals, b_vals, c_tgt=None, anchor_c=False):
+        for i, nid in enumerate(self.A):
+            self.nodes[nid]['x'] = float(a_vals[min(i, len(a_vals)-1)])
+        for i, nid in enumerate(self.B):
+            self.nodes[nid]['x'] = float(b_vals[min(i, len(b_vals)-1)])
+        fixed = set(self.A) | set(self.B) | set(self.C)
+        for nid in self.nodes:
+            if nid not in fixed:
+                self.nodes[nid]['x'] = 0.5; self.nodes[nid]['vel'] = 0.0
+        for i, nid in enumerate(self.C):
+            self.nodes[nid]['vel'] = 0.0
+            if anchor_c and c_tgt is not None:
+                self.nodes[nid]['x'] = float(c_tgt[min(i, len(c_tgt)-1)])
+                self.nodes[nid]['anchored'] = True
+            else:
+                self.nodes[nid]['anchored'] = False
+                self.nodes[nid]['x'] = 0.5
+
+    def phys_step(self, ns=MICRO, anchor_c=True):
+        cs = set(self.C)
+        for _ in range(ns):
+            F = {nid: 0.0 for nid in self.nodes}
+            for (u,v), K in self.K.items():
                 f = K * (self.nodes[v]['x'] - self.nodes[u]['x'])
-                forces[u] += f
-                forces[v] -= f
-            
-            for nid, data in self.nodes.items():
-                if not data['anchored']:
-                    f = forces[nid] - (0.05 * data['x']) # Weak grounding
-                    data['vel'] = data['vel'] * DAMPING + f * DT
-                    data['x'] += data['vel'] * DT
-                    
-                    # MAGICAL FIX: Bounding prevents mathematical explosion
-                    data['x'] = max(-2.0, min(2.0, data['x']))
-
-    def get_predictions(self):
-        return [self.nodes[n]['x'] for n in self.c_nodes]
-
-    def lms_update(self, target_vec, mode='train'):
-        errors = {n: 0.0 for n in self.nodes}
-        for i, nid in enumerate(self.c_nodes):
-            errors[nid] = self.nodes[nid]['x'] - target_vec[i]
-            
-        # Deep Error Diffusion
-        for _ in range(5):
-            next_err = dict(errors)
-            for (u, v), K in self.springs.items():
-                weight = min(abs(K) * 0.1, 0.4)
-                next_err[u] += weight * errors[v]
-                next_err[v] += weight * errors[u]
-            for n in errors: next_err[n] *= 0.85 # Decay to prevent error explosion
-            errors = next_err
-
-        for key in self.springs:
-            u, v = key
-            # True gradient formulation
-            err_gradient = (errors[u] - errors[v]) * (self.nodes[u]['x'] - self.nodes[v]['x'])
-            
-            if mode == 'train':
-                # FIXED: MUST BE += TO MINIMIZE ERROR!
-                self.springs[key] += LR * err_gradient
-                self.fisher[key] = FISHER_DECAY * self.fisher[key] + (1 - FISHER_DECAY) * (err_gradient ** 2)
-            elif mode == 'infer':
-                penalty = EWC_LAMBDA * self.fisher[key] * (self.springs[key] - self.anchor_k[key])
-                self.springs[key] += (LR * 0.5 * err_gradient) - penalty
-                
-            # Stable K bounds
-            self.springs[key] = max(-1.0, min(3.0, self.springs[key]))
-
-    def save_anchors(self):
-        self.anchor_k = dict(self.springs)
+                F[u] += f; F[v] -= f
+            for nid, nd in self.nodes.items():
+                if nd['anchored'] or (nid in cs and anchor_c): continue
+                nd['vel'] = nd['vel']*DAMP + (F[nid] - GND*(nd['x']-0.5))*DT
+                nd['x'] += nd['vel']*DT
+
+    def c_phys(self): return [self.nodes[nid]['x'] for nid in self.C]
+
+    # ── STATE ─────────────────────────────────────────────────────────────────
+
+    def node_state(self):
+        return {nid: {
+            'x':        round(nd['x'], 4),
+            'vel':      round(abs(nd['vel']), 4),
+            'anchored': nd['anchored'],
+            'row':      nd['row'],
+            'kind':     nd['kind'],
+            'px':       nd['px'],
+            'py':       nd['py'],
+        } for nid, nd in self.nodes.items()}
+
+    def spring_state(self):
+        # Return keyed by "ri_ci|ri_ci" for display
+        out = {}
+        for (u,v), K in self.K.items():
+            out[f"{u}|{v}"] = {
+                'k':    round(K, 4),
+                'fish': round(self.fisher[(u,v)], 5),
+                'vert': (u,v) in self.vert,
+                'u_px': self.nodes[u]['px'], 'u_py': self.nodes[u]['py'],
+                'v_px': self.nodes[v]['px'], 'v_py': self.nodes[v]['py'],
+            }
+        return out
+
+    def tri_state(self):
+        out = []
+        for (u,v,w) in self.tris:
+            nu, nv, nw = self.nodes[u], self.nodes[v], self.nodes[w]
+            ku = self.K.get(self._ek(u,v), 0)
+            kv = self.K.get(self._ek(v,w), 0)
+            kw = self.K.get(self._ek(u,w), 0)
+            out.append({
+                'pos':    [[nu['px'],nu['py']], [nv['px'],nv['py']], [nw['px'],nw['py']]],
+                'avg_k':  round((ku+kv+kw)/3, 4),
+                'stress': round(abs(nu['x']-nv['x'])+abs(nv['x']-nw['x'])+abs(nu['x']-nw['x']), 4),
+            })
+        return out
+
+
+# ── ENGINE ────────────────────────────────────────────────────────────────────
 
 class Engine:
     def __init__(self):
-        self.mesh = PristineMesh()
-        self.mode = 'idle'
-        self.running = False
-        self.queue = collections.deque()
-        self.logs = []
-        self.iter = 0
-        self.train_data = []
-        self.test_data = []
-        self.error_hist = []
-        self.current_err = 0.0
-        self.current_type = '—'
-        self.test_results = []
-
-    def add_log(self, msg):
-        self.logs.insert(0, f"[{self.iter:05d}] {msg}")
-        if len(self.logs) > 40: self.logs.pop()
-
-    def run_step(self):
-        if not self.queue:
-            self.running = False
-            self.add_log("Queue empty. Standing by.")
-            return
-            
-        sample = self.queue.popleft()
-        self.current_type = sample['type']
-        
-        self.mesh.set_inputs(sample['a'], sample['b'])
-        self.mesh.settle(steps=25)
-        preds = self.mesh.get_predictions()
-        
-        if sample['type'] != 'manual':
-            # Clean Mean Absolute Error
-            err = float(np.mean(np.abs(np.array(preds) - np.array(sample['c']))))
-            if math.isnan(err): err = 1.0 # Safety catch
-            
-            self.current_err = err
-            self.error_hist.append(err)
-            if len(self.error_hist) > 100: self.error_hist.pop(0)
-
-            if self.mode == 'infer':
-                self.test_results.append({'type': self.current_type, 'err': err})
-
-            # Apply correct LMS + EWC
-            self.mesh.lms_update(sample['c'], mode=self.mode)
+        self.mesh        = Mesh(n=1)
+        self.mode        = 'idle'
+        self.running     = False
+        self.q           = collections.deque()
+        self.logs        = []
+        self.iter        = 0
+        self.step_cnt    = 0
+        self.error       = 0.0
+        self.c_pred      = [0.5]
+        self.c_tgt       = None
+        self.cur_type    = '—'
+        self.history     = []
+        self.train_data  = []
+        self.test_data   = []
+        self.test_res    = []
+
+    def log(self, msg):
+        self.logs.insert(0, f"[{self.iter:06d}] {msg}")
+        if len(self.logs) > 60: self.logs.pop()
+
+    # ── DATA ──────────────────────────────────────────────────────────────────
+
+    def load_data(self, tr='data/train.json', te='data/test.json'):
+        with open(tr) as f: self.train_data = json.load(f)
+        with open(te) as f: self.test_data  = json.load(f)
+        # Detect n from data
+        n = len(self.train_data[0]['A'])
+        if n != self.mesh.n:
+            self.mesh = Mesh(n=n)
+            self.log(f"Mesh rebuilt for n={n}")
+        ood = sum(1 for d in self.test_data if d['type']=='heavy_b')
+        self.log(f"Data: {len(self.train_data)} train | {len(self.test_data)} test ({ood} OOD) | n={n}")
+
+    # ── VISUAL STEP ───────────────────────────────────────────────────────────
+
+    def phys_tick(self):
+        anchor = (self.mode == 'training')
+        self.mesh.phys_step(MICRO, anchor_c=anchor)
+
+        if self.c_tgt is not None:
+            c_p = self.mesh.c_phys()
+            errs = [c_p[i] - float(self.c_tgt[i]) for i in range(self.mesh.n)]
+            self.error  = float(np.sqrt(sum(e**2 for e in errs)))
+            self.c_pred = [round(v,4) for v in c_p]
         else:
-            self.current_err = 0.0
-        
+            self.error = 0.0
+
+        self.history.append(round(abs(self.error), 5))
+        if len(self.history) > 200: self.history.pop(0)
+
+        self.step_cnt += 1
+        conv    = abs(self.error) < CONV
+        timeout = self.step_cnt >= MAXS
+
+        if conv or timeout:
+            tag = '✓' if conv else '⚠'
+            ood = self.cur_type == 'heavy_b'
+            self.log(f"{tag}{'[OOD]' if ood else ''} [{self.cur_type}] err={self.error:.4f}")
+            if self.mode == 'inference' and self.c_tgt is not None:
+                self.test_res.append({
+                    'type': self.cur_type, 'abs': round(abs(self.error),5),
+                    'ok': conv, 'steps': self.step_cnt, 'ood': ood,
+                })
+            return self._next()
+
+        # Inference-time K update (EWC protected)
+        if self.mode == 'inference' and self.c_tgt is not None:
+            self.mesh.lms_update(
+                [self.mesh.nodes[nid]['x'] for nid in self.mesh.A],
+                [self.mesh.nodes[nid]['x'] for nid in self.mesh.B],
+                self.c_tgt, ewc=True
+            )
+
         self.iter += 1
-        if self.iter % 5 == 0 or sample['type'] == 'manual':
-            self.add_log(f"[{self.current_type}] err: {self.current_err:.4f}")
+        return True
 
-    def train_offline(self, epochs):
+    def _next(self):
+        if self.q:
+            p = self.q.popleft()
+            self._load(p)
+            return True
         self.running = False
-        self.mode = 'train'
-        self.add_log(f"⚡ Offline Training: {epochs} epochs...")
-        for ep in range(epochs):
+        self.log("◼ Queue done.")
+        return False
+
+    def _load(self, p):
+        self.cur_type = p['type']
+        self.c_tgt    = p.get('C')
+        self.step_cnt = 0
+        anchor = (self.mode == 'training')
+        self.mesh.set_inputs(p['A'], p['B'], p.get('C'), anchor_c=anchor)
+
+    def _fill(self, data):
+        self.q.clear()
+        for d in data: self.q.append(d)
+        if self.q: self._load(self.q.popleft())
+
+    # ── OFFLINE TRAINING (fast, no display) ───────────────────────────────────
+
+    def train_offline(self, epochs=5):
+        self.running = False; self.mode = 'training'
+        self.log(f"⚡ Offline LMS: {epochs} epochs…")
+        for ep in range(1, epochs+1):
             random.shuffle(self.train_data)
-            errs = []
-            for sample in self.train_data:
-                self.mesh.set_inputs(sample['a'], sample['b'])
-                self.mesh.settle(20)
-                self.mesh.lms_update(sample['c'], mode='train')
-                preds = self.mesh.get_predictions()
-                e = np.mean(np.abs(np.array(preds) - np.array(sample['c'])))
-                if not math.isnan(e): errs.append(e)
-                
-            avg_e = np.mean(errs) if errs else 0.0
-            self.add_log(f"Ep {ep+1} | Avg Err: {avg_e:.4f}")
-            print(f"Epoch {ep+1} | Avg Err: {avg_e:.4f}")
-            
-        self.mesh.save_anchors()
-        self.add_log("✓ Training Complete. EWC Anchors saved.")
+            tot, conv = 0.0, 0
+            for s in self.train_data:
+                for _ in range(MAXS):
+                    e, _ = self.mesh.lms_update(s['A'], s['B'], s['C'], ewc=False)
+                    if e < CONV: conv += 1; break
+                tot += e
+            avg = tot / max(len(self.train_data), 1)
+            pct = 100*conv/max(len(self.train_data), 1)
+            msg = f"  Ep {ep}/{epochs}: avg|e|={avg:.4f}  conv={pct:.1f}%"
+            self.log(msg); print(msg)
+        self.mesh.K0 = dict(self.mesh.K)     # save EWC anchors
+        self.log("✓ Done. EWC anchors saved.")
         self.mode = 'idle'
 
-    def get_accuracy_summary(self):
-        acc = {}
-        for r in self.test_results:
+    # ── START HELPERS ─────────────────────────────────────────────────────────
+
+    def start_visual(self, n=None):
+        data = random.sample(self.train_data, min(n or len(self.train_data), len(self.train_data)))
+        self._fill(data); self.mode='training'; self.running=True
+        self.log(f"▶ Visual train: {len(data)}")
+
+    def start_infer(self, n=None):
+        data = self.test_data[:n] if n else self.test_data
+        self.test_res=[]; self._fill(data); self.mode='inference'; self.running=True
+        ood = sum(1 for d in data if d['type']=='heavy_b')
+        self.log(f"▶ Inference: {len(data)} ({ood} OOD)")
+
+    # ── ACCURACY ──────────────────────────────────────────────────────────────
+
+    def acc(self):
+        out = {}
+        for r in self.test_res:
             t = r['type']
-            if t not in acc: acc[t] = {'n': 0, 'sum_e': 0.0}
-            acc[t]['n'] += 1
-            acc[t]['sum_e'] += r['err']
-        return {t: {'n': v['n'], 'avg_err': round(v['sum_e']/v['n'], 4)} for t, v in acc.items()}
+            if t not in out: out[t] = {'n':0,'ok':0,'se':0.0,'ss':0,'ood':r['ood']}
+            out[t]['n']+=1; out[t]['ok']+=int(r['ok'])
+            out[t]['se']+=r['abs']; out[t]['ss']+=r['steps']
+        return {t:{
+            'n':v['n'], 'acc':round(100*v['ok']/max(v['n'],1),1),
+            'avg_err':round(v['se']/max(v['n'],1),4),
+            'avg_steps':round(v['ss']/max(v['n'],1),1),
+            'ood':v['ood'],
+        } for t,v in out.items()}
+
+    # ── STATE ─────────────────────────────────────────────────────────────────
+
+    def state(self):
+        return {
+            'nodes':      self.mesh.node_state(),
+            'springs':    self.mesh.spring_state(),
+            'triangles':  self.mesh.tri_state(),
+            'widths':     self.mesh.W,
+            'n':          self.mesh.n,
+            'n_springs':  len(self.mesh.K),
+            'n_vert':     len(self.mesh.vert),
+            'error':      round(self.error, 5),
+            'c_pred':     self.c_pred,
+            'c_tgt':      [round(v,4) for v in self.c_tgt] if self.c_tgt else None,
+            'iter':       self.iter,
+            'step_cnt':   self.step_cnt,
+            'logs':       self.logs,
+            'history':    self.history[-120:],
+            'running':    self.running,
+            'mode':       self.mode,
+            'cur_type':   self.cur_type,
+            'q_size':     len(self.q),
+            'train_size': len(self.train_data),
+            'test_size':  len(self.test_data),
+            'type_acc':   self.acc(),
+            'n_done':     len(self.test_res),
+        }
+
+
+# ── SERVER ────────────────────────────────────────────────────────────────────
 
 engine = Engine()
-try:
-    with open('data/train.json') as f: engine.train_data = json.load(f)
-    with open('data/test.json') as f: engine.test_data = json.load(f)
-    engine.add_log("Data loaded successfully.")
-except Exception as e:
-    engine.add_log(f"Error loading data: {str(e)}")
-
-def loop():
+try:    engine.load_data()
+except Exception as e: engine.log(f"⚠ No data — run: python data_gen.py  ({e})")
+
+
+def _loop():
     while True:
-        if engine.running: engine.run_step()
-        time.sleep(0.06)
-threading.Thread(target=loop, daemon=True).start()
+        if engine.running: engine.phys_tick()
+        time.sleep(0.028)
+
+threading.Thread(target=_loop, daemon=True).start()
+
 
 @app.get("/", response_class=HTMLResponse)
 async def ui(): return FileResponse("index.html")
 
 @app.get("/state")
-async def state():
-    return {
-        'nodes': engine.mesh.nodes,
-        'springs': {f"{u}|{v}": k for (u, v), k in engine.mesh.springs.items()},
-        'error': engine.current_err,
-        'hist': engine.error_hist,
-        'mode': engine.mode,
-        'running': engine.running,
-        'logs': engine.logs,
-        'current_type': engine.current_type,
-        'queue_size': len(engine.queue),
-        'type_acc': engine.get_accuracy_summary(),
-        'dim': DIM
-    }
-
-@app.post("/train")
-async def train(data: dict):
-    ep = int(data.get('epochs', 5))
+async def get_state(): return engine.state()
+
+@app.post("/train_offline")
+async def t_offline(d: dict = {}):
+    ep = int(d.get('epochs', 5))
     threading.Thread(target=engine.train_offline, args=(ep,), daemon=True).start()
     return {"ok": True}
 
+@app.post("/train_visual")
+async def t_visual(d: dict = {}):
+    engine.start_visual(); return {"ok": True}
+
 @app.post("/infer")
-async def infer(data: dict):
-    n = int(data.get('n', 200))
-    engine.mode = 'infer'
-    engine.test_results = []
-    engine.queue.clear()
-    engine.queue.extend(engine.test_data[:n])
-    engine.running = True
-    return {"ok": True}
+async def infer(d: dict = {}):
+    engine.start_infer(n=d.get('n')); return {"ok": True}
 
-@app.post("/manual")
-async def manual(data: dict):
-    try:
-        a_vec = [float(x.strip()) for x in data.get('a', '').split(',')]
-        b_vec = [float(x.strip()) for x in data.get('b', '').split(',')]
-        if len(a_vec) != DIM or len(b_vec) != DIM:
-            return {"ok": False, "error": f"Vectors must be exactly length {DIM}"}
-        
-        engine.mode = 'manual'
-        engine.queue.clear()
-        engine.queue.append({'a': a_vec, 'b': b_vec, 'c': [0]*DIM, 'type': 'manual'})
-        engine.running = True
-        return {"ok": True}
-    except Exception as e:
-        return {"ok": False, "error": str(e)}
+@app.post("/set_n")
+async def set_n(d: dict):
+    engine.running = False
+    n = max(1, min(8, int(d.get('n', 1))))
+    engine.mesh = Mesh(n=n)
+    engine.log(f"Mesh rebuilt: n={n}  rows={len(engine.mesh.W)}  springs={len(engine.mesh.K)}")
+    return {"ok": True}
 
 @app.post("/halt")
-async def halt(): engine.running = False; return {"ok": True}
+async def halt(): engine.running=False; return {"ok":True}
+
+@app.post("/reset")
+async def reset():
+    engine.running=False
+    engine.mesh=Mesh(n=engine.mesh.n)
+    engine.log("Springs re-initialised."); return {"ok":True}
 
 if __name__ == "__main__":
     import uvicorn