Update app.py

app.py

@@ -1,41 +1,9 @@
 """
-main.py  —  Scalar Triangulated Hourglass Mesh  v4
-
-WHAT CHANGED FROM v3:
-  • Every node is a single scalar float  (not a D-vector)
-  • Every spring K is a single scalar    (not a D×D matrix)
-  • Topology is a triangulated row-grid  (matches the sketch)
-  • Physics: Hooke's law  F_i = Σ_j K_ij(x_j − x_i) − ε·x_i
-  • Learning: Contrastive Hebbian (CHL) — two-phase equilibrium
-  • No layer norm, no matrix multiply, no embedding vectors
-
-TOPOLOGY (default n_half=3, max_w=4):
-
-    A                Row 0  width 1   ← scalar input, anchored
-   / \
-  ·   ·              Row 1  width 2
- / \ / \
-·   ·   ·   ·        Row 2  width 4   ← widest upper
- \ / \ / \ /
-  ·   ·   ·          Row 3  width 3? ... 
-     ...
-    [C]              neck row          ← scalar output, anchored in training
-     ...
-  ·   ·   ·
- / \ / \ / \
-·   ·   ·   ·        widest lower
- \ / \ /
-  ·   ·
-   \ /
-    B                last row          ← scalar input, anchored
-
-SPRINGS: one scalar K per undirected edge.  K can be negative (repulsive).
-PHYSICS: Hooke's law with small grounding force  F = K(x_j−x_i),  F_ground = −ε·x_i
-LEARNING: CHL  ΔK_ij = η·(x_i_clamp·x_j_clamp − x_i_free·x_j_free)
+main.py
+Perfect Triangulated Grid + LMS Learning + Inference EWC
 """
-
 import numpy as np
-import time, collections, threading, json, random
+import time, collections, threading, json, random, math
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
@@ -43,586 +11,240 @@ from fastapi.middleware.cors import CORSMiddleware
 app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
-# ── PHYSICS CONSTANTS ─────────────────────────────────────────────────────────
-DT          = 0.10
-DAMPING     = 0.65
-GROUND_EPS  = 0.04   # weak restoring force → 0, prevents drift/explosion
-SETTLE_N    = 60     # steps to near-equilibrium per CHL phase
-CONV_THRESH = 0.03
-MAX_STEPS   = 400
-LR          = 0.006
-K_CLIP      = 12.0
-MICRO       = 10     # display steps per server tick
-
-
-# ── ROW WIDTH HELPER ──────────────────────────────────────────────────────────
-
-def make_hourglass_widths(n_half=3, max_w=4):
-    """
-    Symmetric hourglass:
-    apex(1) → expand → max_w → contract → neck(1) → expand → max_w → contract → apex(1)
-
-    Returns (widths_list, neck_row_index)
-    """
-    n = n_half + 2   # rows in the upper half (including apex + neck)
-    upper = []
-    for i in range(n):
-        frac = i / (n - 1)
-        if frac <= 0.5:
-            w = round(1 + 2 * frac * (max_w - 1))
-        else:
-            w = round(max_w - 2 * (frac - 0.5) * (max_w - 1))
-        upper.append(max(1, w))
-    upper[0]  = 1   # apex
-    upper[-1] = 1   # neck
-
-    full = upper + upper[::-1][1:]   # mirror; neck shared, not duplicated
-    neck_row = len(upper) - 1
-    return full, neck_row
-
-
-# ── MESH ──────────────────────────────────────────────────────────────────────
-
-class TriMesh:
-    """
-    Scalar triangulated hourglass mesh.
-
-    Each node holds:  x (scalar position), vel (scalar velocity)
-    Each edge holds:  K (scalar spring stiffness, signed)
-
-    The mesh learns K values via Contrastive Hebbian Learning so that,
-    at equilibrium, the free C node matches the target C value.
-    """
-
-    def __init__(self, n_half=3, max_w=4):
-        self.n_half = n_half
-        self.max_w  = max_w
-        self._build()
-
-    # ── BUILD ─────────────────────────────────────────────────────────────────
-
-    def _build(self):
-        widths, neck_row = make_hourglass_widths(self.n_half, self.max_w)
-        self.row_widths  = widths
-        self.neck_row    = neck_row
-        n_rows           = len(widths)
-
-        self.layers  = []
-        self.nodes   = {}   # name → dict
-        self.row_of  = {}
-
-        counter = [0]
-        def mk(ri, ci, kind):
-            if kind == 'A':
-                name = f'A{ci}'
-            elif kind == 'B':
-                name = f'B{ci}'
-            elif kind == 'C':
-                name = f'C{ci}'
-            else:
-                name = f'H{counter[0]}'
-            counter[0] += 1
-            self.nodes[name] = {
-                'x':       0.0,
-                'vel':     0.0,
-                'anchored': kind in ('A', 'B'),
-                'row':     ri,
-                'col':     ci,
-                'kind':    kind,
-            }
-            self.row_of[name] = ri
-            return name
-
-        for ri, w in enumerate(widths):
-            if ri == 0:
-                row = [mk(ri, ci, 'A') for ci in range(w)]
-            elif ri == neck_row:
-                row = [mk(ri, ci, 'C') for ci in range(w)]
-            elif ri == n_rows - 1:
-                row = [mk(ri, ci, 'B') for ci in range(w)]
-            else:
-                row = [mk(ri, ci, 'H') for ci in range(w)]
-            self.layers.append(row)
-
-        self.a_nodes = self.layers[0]
-        self.c_nodes = self.layers[neck_row]
-        self.b_nodes = self.layers[-1]
-
-        # Springs: undirected, key = (u,v) with u < v lexicographically
+DIM = 8
+LR = 0.05
+EWC_LAMBDA = 0.8
+FISHER_DECAY = 0.95
+DAMPING = 0.5
+DT = 0.2
+
+class PristineMesh:
+    def __init__(self, n_dim=DIM):
+        self.n_dim = n_dim
+        self.nodes = {}
         self.springs = {}
-        self.adj     = {n: [] for n in self.nodes}
-
-        for ri in range(n_rows):
-            row = self.layers[ri]
-            # Horizontal springs
-            for ci in range(len(row) - 1):
-                self._add_spring(row[ci], row[ci + 1])
-            # Inter-row springs to next row
-            if ri < n_rows - 1:
-                self._connect_rows(self.layers[ri], self.layers[ri + 1])
-
-        # Init K: small positive, slightly randomised
-        for key in self.springs:
-            self.springs[key] = random.uniform(0.25, 0.55)
-
-        # Precompute 2-D display positions (row-based, centred)
-        self._positions = {}
-        for ri, row in enumerate(self.layers):
-            y = 1.0 - 2.0 * ri / max(n_rows - 1, 1)
-            w = len(row)
-            for ci, nid in enumerate(row):
-                x = (2 * ci - (w - 1)) / max(w - 1, 1) if w > 1 else 0.0
-                self._positions[nid] = (round(x * 4.5, 3), round(y * 4.5, 3))
-
-        # Precompute triangles for visualisation
-        self._triangles = self._find_triangles()
-
-    def _ek(self, a, b):
-        return (a, b) if a < b else (b, a)
-
-    def _add_spring(self, a, b):
-        key = self._ek(a, b)
-        if key not in self.springs:
-            self.springs[key] = 0.4
-            self.adj[a].append(b)
-            self.adj[b].append(a)
-
-    def _connect_rows(self, ra, rb):
-        """Connect two adjacent rows: nearest-neighbour bipartite mapping."""
-        wa, wb = len(ra), len(rb)
-        if wa <= wb:
-            for i, a in enumerate(ra):
-                j0 = (i * wb) // wa
-                j1 = max(j0 + 1, ((i + 1) * wb + wa - 1) // wa)
-                for j in range(min(j1, wb)):
-                    self._add_spring(a, rb[j])
-        else:
-            for j, b in enumerate(rb):
-                i0 = (j * wa) // wb
-                i1 = max(i0 + 1, ((j + 1) * wa + wb - 1) // wb)
-                for i in range(min(i1, wa)):
-                    self._add_spring(ra[i], b)
-
-    def _find_triangles(self):
-        """Find all triangles (3 mutually connected nodes) for visualisation."""
-        tris = []
-        adj_set = {n: set(ns) for n, ns in self.adj.items()}
-        checked = set()
-        for u, v in self.springs:
-            for w in adj_set[u] & adj_set[v]:
-                key = tuple(sorted([u, v, w]))
-                if key not in checked:
-                    tris.append(key)
-                    checked.add(key)
-        return tris
-
-    # ── PHYSICS ───────────────────────────────────────────────────────────────
-
-    def _hooke_step(self, n_steps, anchor_c):
-        """Hooke's law + grounding.  anchor_c=True keeps C nodes fixed."""
-        c_set = set(self.c_nodes)
-        for _ in range(n_steps):
-            # Accumulate forces
-            forces = {nid: 0.0 for nid in self.nodes}
+        self.fisher = {}
+        self.anchor_k = {}
+        self._build_lattice()
+
+    def _build_lattice(self):
+        """Builds a perfect geometric honeycomb/diamond lattice."""
+        # Define the row widths to create the bulges
+        # Example for N=8: A(8) -> 9 -> 10 -> 9 -> C(8) -> 9 -> 10 -> 9 -> B(8)
+        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 # sqrt(3)/2 for perfect equilateral triangles
+        
+        # 1. Place Nodes
+        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):
+                x = x_offset + c
+                nid = f"{kind}_r{r}_c{c}"
+                self.nodes[nid] = {
+                    'x': 0.0, 'vel': 0.0, 'kind': kind,
+                    'pos': (x, y), 'anchored': kind in ['A', 'B']
+                }
+
+        # 2. Connect nearest neighbors perfectly
+        node_ids = list(self.nodes.keys())
+        self.adj = {n: [] for n in node_ids}
+        
+        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']
+                dist = math.hypot(p1[0]-p2[0], p1[1]-p2[1])
+                
+                # If distance is ~1.0, they are adjacent in the lattice
+                if dist < 1.05:
+                    key = tuple(sorted([n1, n2]))
+                    self.springs[key] = random.uniform(0.4, 0.6)
+                    self.fisher[key] = 0.0
+                    self.anchor_k[key] = self.springs[key]
+                    self.adj[n1].append(n2)
+                    self.adj[n2].append(n1)
+                    
+        self.c_nodes = [n for n in self.nodes if self.nodes[n]['kind'] == 'C']
+        self.a_nodes = [n for n in self.nodes if self.nodes[n]['kind'] == 'A']
+        self.b_nodes = [n for n in self.nodes if self.nodes[n]['kind'] == 'B']
+
+    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=40):
+        for _ in range(steps):
+            forces = {n: 0.0 for n in self.nodes}
             for (u, v), K in self.springs.items():
                 f = K * (self.nodes[v]['x'] - self.nodes[u]['x'])
                 forces[u] += f
                 forces[v] -= f
-            # Integrate
-            for nid, nd in self.nodes.items():
-                if nd['anchored']:
-                    continue
-                if nid in c_set and anchor_c:
-                    continue
-                f = forces[nid] - GROUND_EPS * nd['x']
-                nd['vel'] = nd['vel'] * DAMPING + f * DT
-                nd['x']  += nd['vel'] * DT
-
-    def settle(self, n=SETTLE_N, anchor_c=True):
-        self._hooke_step(n, anchor_c)
-
-    # ── PROBLEM SETUP ─────────────────────────────────────────────────────────
-
-    def set_problem(self, a, b, c_target=None, mode='training'):
-        # Inputs
-        for nid in self.a_nodes:
-            self.nodes[nid]['x'] = float(a)
-        for nid in self.b_nodes:
-            self.nodes[nid]['x'] = float(b)
-
-        # Reset hidden nodes
-        c_set = set(self.c_nodes)
-        for nid, nd in self.nodes.items():
-            if not nd['anchored'] and nid not in c_set:
-                nd['x'] = 0.0;  nd['vel'] = 0.0
-
-        # C setup
-        c0 = self.nodes[self.c_nodes[0]]
-        c0['vel'] = 0.0
-        if mode == 'training' and c_target is not None:
-            c0['x']        = float(c_target)
-            c0['anchored'] = True
-            self._c_target = float(c_target)
-        else:
-            c0['anchored'] = False
-            c0['x']        = float(a + b) / 2   # warm start near midpoint
-            c0['vel']      = 0.0
-            self._c_target = float(c_target) if c_target is not None else None
-
-    def predict(self):
-        return float(np.mean([self.nodes[n]['x'] for n in self.c_nodes]))
-
-    def free_c(self):
-        for nid in self.c_nodes:
-            self.nodes[nid]['anchored'] = False
-            self.nodes[nid]['vel']      = 0.0
-
-    def reset_hidden(self):
-        c_set = set(self.c_nodes)
-        fixed = set(self.a_nodes) | set(self.b_nodes) | c_set
-        for nid in self.nodes:
-            if nid not in fixed:
-                self.nodes[nid]['x']   = 0.0
-                self.nodes[nid]['vel'] = 0.0
-
-    # ── CHL LEARNING ─────────────────────────────────────────────────────────
-
-    def chl_update(self, a, b, c_target):
+            
+            for nid, data in self.nodes.items():
+                if not data['anchored']:
+                    # Grounding force to prevent floating
+                    f = forces[nid] - (0.05 * data['x'])
+                    data['vel'] = data['vel'] * DAMPING + f * DT
+                    data['x'] += data['vel'] * DT
+
+    def get_predictions(self):
+        return [self.nodes[n]['x'] for n in self.c_nodes]
+
+    def lms_update(self, target_vec, mode='train'):
         """
-        Contrastive Hebbian Learning.
-
-        Phase 1 — CLAMPED:
-          A, B, C all anchored.  Hidden nodes settle to the state that is
-          consistent with (A, B, C=target).  Record x_clamp.
-
-        Phase 2 — FREE:
-          Only A, B anchored.  C and hidden nodes settle freely.
-          Record x_free and C_prediction.
-
-        Update:  ΔK_ij = η · (x_i_clamp·x_j_clamp − x_i_free·x_j_free)
-
-        Effect: K values shift to make the free equilibrium look more like
-        the clamped one, i.e., C_free → C_target over many samples.
+        Network-wide LMS: Backpropagates the error from C through the mesh.
         """
-        # ── Clamped phase ───────────────────────────────────────────────────
-        self.set_problem(a, b, c_target, mode='training')
-        self.reset_hidden()
-        self.settle(SETTLE_N, anchor_c=True)
-        x_c = {nid: self.nodes[nid]['x'] for nid in self.nodes}
-
-        # ── Free phase ──────────────────────────────────────────────────────
-        self.free_c()
-        self.reset_hidden()
-        self.settle(SETTLE_N, anchor_c=False)
-        x_f = {nid: self.nodes[nid]['x'] for nid in self.nodes}
-        pred  = self.predict()
-        error = pred - c_target
-
-        # ── Weight update ────────────────────────────────────────────────────
-        for (u, v) in self.springs:
-            delta = x_c[u] * x_c[v] - x_f[u] * x_f[v]
-            new_k = self.springs[(u, v)] + LR * delta
-            self.springs[(u, v)] = max(-K_CLIP, min(K_CLIP, new_k))
-
-        return error, pred
-
-    # ── STATE ─────────────────────────────────────────────────────────────────
-
-    def node_state(self):
-        out = {}
-        for nid, nd in self.nodes.items():
-            out[nid] = {
-                'x':       round(nd['x'], 4),
-                'vel':     round(nd['vel'], 4),
-                'anchored': nd['anchored'],
-                'row':     nd['row'],
-                'col':     nd['col'],
-                'kind':    nd['kind'],
-                'pos':     list(self._positions[nid]),
-            }
-        return out
-
-    def spring_state(self):
-        out = {}
-        for (u, v), K in self.springs.items():
-            out[f"{u}↔{v}"] = round(K, 4)
-        return out
-
-    def triangle_state(self):
-        tris = []
-        for (u, v, w) in self._triangles:
-            ku = self.springs.get(self._ek(u,v), 0)
-            kv = self.springs.get(self._ek(v,w), 0)
-            kw = self.springs.get(self._ek(u,w), 0)
-            avg_k = (ku + kv + kw) / 3
-            tris.append({
-                'nodes': [u, v, w],
-                'pos':   [list(self._positions[u]),
-                           list(self._positions[v]),
-                           list(self._positions[w])],
-                'avg_k': round(avg_k, 4),
-                'stress': round(abs(self.nodes[u]['x'] - self.nodes[v]['x']) +
-                                abs(self.nodes[v]['x'] - self.nodes[w]['x']) +
-                                abs(self.nodes[u]['x'] - self.nodes[w]['x']), 4),
-            })
-        return tris
-
+        # 1. Compute errors at C
+        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]
+            
+        # 2. Backprop errors to hidden layers topologically
+        for _ in range(3): # Smooth error outward
+            next_err = dict(errors)
+            for (u, v), K in self.springs.items():
+                # Error flows proportionally to stiffness
+                next_err[u] += K * errors[v] * 0.1
+                next_err[v] += K * errors[u] * 0.1
+            errors = next_err
 
-# ── ENGINE ────────────────────────────────────────────────────────────────────
+        # 3. Update Springs
+        for key in self.springs:
+            u, v = key
+            # The gradient for K_uv is driven by the error difference and displacement
+            err_gradient = (errors[u] - errors[v]) * (self.nodes[u]['x'] - self.nodes[v]['x'])
+            
+            if mode == 'train':
+                self.springs[key] -= LR * err_gradient
+                # Accumulate Fisher info for EWC
+                self.fisher[key] = FISHER_DECAY * self.fisher[key] + (1 - FISHER_DECAY) * (err_gradient ** 2)
+            
+            elif mode == 'infer':
+                # Real-time inference updating with EWC protection
+                penalty = EWC_LAMBDA * self.fisher[key] * (self.springs[key] - self.anchor_k[key])
+                self.springs[key] -= (LR * 0.5 * err_gradient) + penalty
+                
+            self.springs[key] = max(-4.0, min(8.0, self.springs[key])) # Clip to stable bounds
+
+    def save_anchors(self):
+        self.anchor_k = dict(self.springs)
 
 class Engine:
     def __init__(self):
-        self.mesh         = TriMesh(n_half=3, max_w=4)
-        self.mode         = 'idle'
-        self.running      = False
-        self.batch_queue  = collections.deque()
-        self.logs         = []
-        self.iteration    = 0
-        self.step_count   = 0
-        self.error        = 0.0
-        self.prediction   = 0.0
-        self.history      = []
-        self.train_data   = []
-        self.test_data    = []
-        self.c_target     = None
-        self.current_type = '—'
-        self.test_results = []
-
-    def add_log(self, msg):
-        self.logs.insert(0, f"[{self.iteration:06d}] {msg}")
-        if len(self.logs) > 60: self.logs.pop()
-
-    # ── DATA ──────────────────────────────────────────────────────────────────
-
-    def load_data(self, train='data/train.json', test='data/test.json'):
-        with open(train) as f: self.train_data = json.load(f)
-        with open(test)  as f: self.test_data  = json.load(f)
-        ood  = sum(1 for d in self.test_data if d['type'] == 'heavy_b')
-        seen = len(self.test_data) - ood
-        self.add_log(f"Data: {len(self.train_data)} train | "
-                     f"{len(self.test_data)} test ({seen} seen / {ood} OOD)")
-
-    # ── VISUAL TRAINING STEP ─────────────────────────────────────────────────
-
-    def physics_step(self):
-        """One server tick — runs MICRO display steps + optional CHL update."""
-        self.mesh._hooke_step(MICRO, anchor_c=(self.mode == 'training'))
-        self.prediction = self.mesh.predict()
-
-        if self.c_target is not None:
-            self.error = self.prediction - self.c_target
-        else:
-            self.error = 0.0
-
-        self.history.append(round(abs(self.error), 5))
-        if len(self.history) > 200: self.history.pop(0)
-
-        self.step_count += 1
-        converged = abs(self.error) < CONV_THRESH
-        timeout   = self.step_count >= MAX_STEPS
-
-        if converged or timeout:
-            tag = '✓' if converged else '⚠'
-            is_ood = self.current_type == 'heavy_b'
-            self.add_log(f"{tag}{'[OOD]' if is_ood else ''} [{self.current_type}] "
-                         f"err={self.error:.4f} steps={self.step_count}")
-            if self.mode == 'inference' and self.c_target is not None:
-                self.test_results.append({
-                    'type':  self.current_type,
-                    'abs':   round(abs(self.error), 5),
-                    'ok':    converged,
-                    'steps': self.step_count,
-                    'ood':   is_ood,
-                })
-            return self._next_or_stop()
-
-        self.iteration += 1
-        return True
-
-    def _next_or_stop(self):
-        if self.batch_queue:
-            p = self.batch_queue.popleft()
-            self._load_sample(p)
-            return True
-        self.running = False
-        self.add_log("◼ Queue empty.")
-        return False
-
-    def _load_sample(self, p):
-        self.current_type = p['type']
-        self.c_target     = p.get('c')
-        self.step_count   = 0
-        self.mesh.set_problem(p['a'], p['b'],
-                              c_target=p.get('c'),
-                              mode=self.mode)
-
-    def _fill_queue(self, data):
-        self.batch_queue.clear()
-        for d in data:
-            self.batch_queue.append(d)
-        if self.batch_queue:
-            self._load_sample(self.batch_queue.popleft())
-
-    # ── OFFLINE TRAINING (fast, no display) ───────────────────────────────────
-
-    def train_offline(self, epochs=5):
+        self.mesh = PristineMesh()
+        self.mode = 'idle'
         self.running = False
-        self.mode    = 'training'
-        self.add_log(f"⚡ Offline CHL training: {epochs} epoch(s)…")
+        self.queue = collections.deque()
+        self.logs = []
+        self.iter = 0
+        self.train_data = []
+        self.test_data = []
+        self.error_hist = []
+        self.current_err = 0.0
 
-        for ep in range(1, epochs + 1):
+    def add_log(self, msg):
+        self.logs.insert(0, f"[{self.iter:05d}] {msg}")
+        if len(self.logs) > 30: self.logs.pop()
+
+    def run_step(self):
+        if not self.queue:
+            self.running = False
+            return
+            
+        sample = self.queue.popleft()
+        self.mesh.set_inputs(sample['a'], sample['b'])
+        self.mesh.settle(steps=30)
+        preds = self.mesh.get_predictions()
+        
+        # Mean Absolute Error across all N output dimensions
+        err = float(np.mean(np.abs(np.array(preds) - np.array(sample['c']))))
+        self.current_err = err
+        self.error_hist.append(err)
+        if len(self.error_hist) > 100: self.error_hist.pop(0)
+
+        # Apply LMS + EWC
+        self.mesh.lms_update(sample['c'], mode=self.mode)
+        
+        self.iter += 1
+        if self.iter % 10 == 0:
+            self.add_log(f"[{sample['type']}] err: {err:.4f}")
+
+    def train_offline(self, epochs):
+        self.add_log("⚡ Offline Training Started...")
+        for ep in range(epochs):
             random.shuffle(self.train_data)
-            total_err, conv = 0.0, 0
-
+            errs = []
             for sample in self.train_data:
-                err, pred = self.mesh.chl_update(
-                    sample['a'], sample['b'], sample['c']
-                )
-                total_err += abs(err)
-                if abs(err) < CONV_THRESH:
-                    conv += 1
-
-            avg = total_err / 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.add_log(msg); print(msg)
-
-        self.add_log("✓ Offline training complete.")
-        self.mode = 'idle'
-
-    # ── INFERENCE ─────────────────────────────────────────────────────────────
-
-    def start_inference(self, n=None):
-        data = self.test_data[:n] if n else self.test_data
-        self.test_results = []
-        self._fill_queue(data)
-        self.mode    = 'inference'
-        self.running = True
-        ood = sum(1 for d in data if d['type'] == 'heavy_b')
-        self.add_log(f"▶ Inference: {len(data)} samples ({ood} OOD)")
-
-    def start_training_visual(self, n=None):
-        data = random.sample(self.train_data,
-                             min(n or len(self.train_data), len(self.train_data)))
-        self._fill_queue(data)
-        self.mode    = 'training'
-        self.running = True
-        self.add_log(f"▶ Visual training: {len(data)} samples")
-
-    # ── ACCURACY SUMMARY ──────────────────────────────────────────────────────
-
-    def accuracy_summary(self):
-        acc = {}
-        for r in self.test_results:
-            t = r['type']
-            if t not in acc:
-                acc[t] = {'n':0,'ok':0,'sum_e':0.0,'sum_s':0,'ood':r['ood']}
-            acc[t]['n']     += 1
-            acc[t]['ok']    += int(r['ok'])
-            acc[t]['sum_e'] += r['abs']
-            acc[t]['sum_s'] += r['steps']
-        return {
-            t: {
-                'n':        v['n'],
-                'acc':      round(100*v['ok']/max(v['n'],1), 1),
-                'avg_err':  round(v['sum_e']/max(v['n'],1), 4),
-                'avg_steps':round(v['sum_s']/max(v['n'],1), 1),
-                'ood':      v['ood'],
-            }
-            for t, v in acc.items()
-        }
-
-    # ── STATE DICT ────────────────────────────────────────────────────────────
-
-    def state_dict(self):
-        return {
-            'nodes':        self.mesh.node_state(),
-            'springs':      self.mesh.spring_state(),
-            'triangles':    self.mesh.triangle_state(),
-            'layers':       self.mesh.layers,
-            'row_widths':   self.mesh.row_widths,
-            'neck_row':     self.mesh.neck_row,
-            'error':        round(self.error, 5),
-            'prediction':   round(self.prediction, 5),
-            'c_target':     round(self.c_target, 5) if self.c_target else None,
-            'iter':         self.iteration,
-            'step_count':   self.step_count,
-            'logs':         self.logs,
-            'history':      self.history[-120:],
-            'running':      self.running,
-            'mode':         self.mode,
-            'current_type': self.current_type,
-            'queue_size':   len(self.batch_queue),
-            'train_size':   len(self.train_data),
-            'test_size':    len(self.test_data),
-            'type_acc':     self.accuracy_summary(),
-            'n_test_done':  len(self.test_results),
-            'n_half':       self.mesh.n_half,
-            'max_w':        self.mesh.max_w,
-        }
-
-
-# ── SERVER ────────────────────────────────────────────────────────────────────
+                self.mesh.set_inputs(sample['a'], sample['b'])
+                self.mesh.settle(15)
+                self.mesh.lms_update(sample['c'], mode='train')
+                preds = self.mesh.get_predictions()
+                errs.append(np.mean(np.abs(np.array(preds) - np.array(sample['c']))))
+            self.add_log(f"Epoch {ep+1} | Avg Err: {np.mean(errs):.4f}")
+            print(f"Epoch {ep+1} | Avg Err: {np.mean(errs):.4f}")
+        self.mesh.save_anchors()
+        self.add_log("✓ Training Complete. EWC Anchors saved.")
 
 engine = Engine()
 try:
-    engine.load_data()
-except Exception as e:
-    engine.add_log(f"⚠ No data — run: python data_gen.py  ({e})")
-
+    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.")
+except:
+    pass
 
-def run_loop():
+def loop():
     while True:
-        if engine.running:
-            engine.physics_step()
-        time.sleep(0.028)
-
-threading.Thread(target=run_loop, daemon=True).start()
-
+        if engine.running: engine.run_step()
+        time.sleep(0.05)
+threading.Thread(target=loop, daemon=True).start()
 
 @app.get("/", response_class=HTMLResponse)
-async def get_ui(): return FileResponse("index.html")
+async def ui(): return FileResponse("index.html")
 
 @app.get("/state")
-async def get_state(): return engine.state_dict()
-
-@app.post("/train_offline")
-async def train_offline(data: dict = {}):
-    ep = int(data.get('epochs', 5))
-    threading.Thread(target=engine.train_offline, args=(ep,), daemon=True).start()
-    return {"ok": True}
-
-@app.post("/train_visual")
-async def train_visual(data: dict = {}):
-    engine.start_training_visual()
+async def state():
+    return {
+        'nodes': engine.mesh.nodes,
+        'springs': engine.mesh.springs,
+        'error': engine.current_err,
+        'hist': engine.error_hist,
+        'mode': engine.mode,
+        'running': engine.running,
+        'logs': engine.logs
+    }
+
+@app.post("/train")
+async def train():
+    threading.Thread(target=engine.train_offline, args=(5,), daemon=True).start()
     return {"ok": True}
 
 @app.post("/infer")
-async def infer(data: dict = {}):
-    engine.start_inference(n=data.get('n'))
-    return {"ok": True}
-
-@app.post("/set_topo")
-async def set_topo(data: dict):
-    engine.running = False
-    n_half = max(2, min(6, int(data.get('n_half', engine.mesh.n_half))))
-    max_w  = max(2, min(8, int(data.get('max_w',  engine.mesh.max_w))))
-    engine.mesh = TriMesh(n_half=n_half, max_w=max_w)
-    engine.add_log(f"Mesh rebuilt: n_half={n_half} max_w={max_w} "
-                   f"rows={len(engine.mesh.row_widths)} "
-                   f"springs={len(engine.mesh.springs)}")
+async def infer():
+    engine.mode = 'infer'
+    engine.queue.extend(engine.test_data)
+    engine.running = True
     return {"ok": True}
 
 @app.post("/halt")
 async def halt(): engine.running = False; return {"ok": True}
 
-@app.post("/reset")
-async def reset():
-    engine.running = False
-    engine.mesh    = TriMesh(engine.mesh.n_half, engine.mesh.max_w)
-    engine.add_log("Springs re-initialised.")
-    return {"ok": True}
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)