Update app.py

app.py

@@ -1,654 +1,326 @@
-"""
-main.py  —  Elastic Mesh Engine + FastAPI server.
-
-Architecture:
-  Bilateral hourglass:  A (top) ─[U1..Un]─┐
-                                            C (center waist)
-                        B (bot) ─[L1..Ln]─┘
-
-Each node  : x, vel ∈ ℝ^DIM
-Each spring: K ∈ ℝ^(DIM×DIM)  — full linear map per edge
-
-Forward (additive):
-  x_Ui  = K(A,Ui) @ x_A
-  x_Li  = K(B,Li) @ x_B
-  x_C   = Σ K(Ui,C) @ x_Ui  +  Σ K(Li,C) @ x_Li
-
-Training:
-  C anchored at target → K matrices update via matrix LMS
-  one-shot zero-residual for linear problems
-
-Inference:
-  C free → elastic dynamics settle to equilibrium
-  EWC regularisation protects weights from catastrophic forgetting
-  Fisher diagonal accumulates during training
-"""
-
 import numpy as np
-import time, collections, threading, json, pathlib, random
+import time, collections, threading, json, random, math, os, pathlib
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
 
 app = FastAPI()
-app.add_middleware(CORSMiddleware,
-                   allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
-
-# ── CONSTANTS ─────────────────────────────────────────────────────────────────
-DIM         = 32      # embedding dimension (scale to 768 for LLM integration)
-FWD_K       = 1.5     # forward spring stiffness for elastic display
-BACK_A      = 0.40    # backward tension (C pulls on hidden nodes)
-DAMPING     = 0.58    # velocity retention per display micro-step
-DT          = 0.10    # display physics time-step
-MICRO       = 4       # display micro-steps per server tick
-CONV_THRESH = 0.08    # ‖error‖ < this → sample converged
-MAX_STEPS   = 400     # hard cap per sample (prevents infinite loops)
-EWC_LAMBDA  = 0.6     # EWC penalty strength
-FISHER_DECAY= 0.97    # EMA decay for Fisher accumulation
-
-
-class MeshEngine:
-    """
-    Elastic hourglass mesh with matrix spring stiffness.
-
-    The mesh learns to produce C = equilibrium(A, B) such that C lies in the
-    feasibility space satisfying A-constraints while respecting B-objectives.
-    This is not computed — it is converged to.
-    """
-
-    def __init__(self, dim: int = DIM, n_upper: int = 3, n_lower: int = 3):
-        self.dim     = dim
-        self.n_upper = n_upper
-        self.n_lower = n_lower
-        self.mode    = 'idle'          # 'training' | 'inference' | 'idle'
-        self.running = False
-        self.batch_queue  = collections.deque()
-        self.logs         = []
-        self.iteration    = 0
-        self.step_count   = 0          # steps on current sample
-        self.error_norm   = 0.0
-        self.pred_norm    = 0.0
-        self.history      = []
-        self.train_data   = []
-        self.test_data    = []
-        self.c_target     = None       # ground-truth C for current sample (inference)
-        self.current_type = 'unknown'
-        self.test_errors  = []         # list of {type, err, rel} — inference results
-        self._init_mesh()
-
-    # ── TOPOLOGY ──────────────────────────────────────────────────────────────
-
-    def _layers(self):
-        return [
-            ['A'],
-            [f'U{i}' for i in range(1, self.n_upper + 1)],
-            ['C'],
-            [f'L{i}' for i in range(1, self.n_lower + 1)],
-            ['B'],
-        ]
-
-    def _init_mesh(self):
-        self.iteration  = 0
-        self.step_count = 0
-        self.error_norm = 0.0
-        self.pred_norm  = 0.0
-        self.history    = []
-        self.layers     = self._layers()
-        d = self.dim
-
-        # Nodes — each carries a d-vector position and velocity
-        self.nodes = {
-            nid: {
-                'x':       np.zeros(d),
-                'vel':     np.zeros(d),
-                'anchored': nid in ('A', 'B'),
-            }
-            for layer in self.layers for nid in layer
-        }
-
-        # Spring matrices — K ∈ ℝ^(d×d) per edge, Xavier init
-        scale = np.sqrt(2.0 / (d + d))
-        self.K = {}
-        for i in range(1, self.n_upper + 1):
-            uid = f'U{i}'
-            self.K[('A', uid)] = np.random.normal(0, scale, (d, d))
-            self.K[(uid, 'C')] = np.random.normal(0, scale, (d, d))
-        for i in range(1, self.n_lower + 1):
-            lid = f'L{i}'
-            self.K[('B', lid)] = np.random.normal(0, scale, (d, d))
-            self.K[(lid, 'C')] = np.random.normal(0, scale, (d, d))
-
-        # EWC: Fisher diagonal (per element of each K matrix)
-        self.fisher = {k: np.zeros((d, d)) for k in self.K}
-        self.K_anchor = {k: v.copy() for k, v in self.K.items()}
-
-    # ── PROBLEM SETUP ────────────────────────────��────────────────────────────
-
-    def set_problem(self, a_vec, b_vec, c_target=None, ptype='unknown'):
-        d = self.dim
-        self.nodes['A']['x'] = np.asarray(a_vec, dtype=float)[:d]
-        self.nodes['B']['x'] = np.asarray(b_vec, dtype=float)[:d]
-        self.current_type    = ptype
-        self.step_count      = 0
-
-        # Reset free nodes for fresh elastic oscillation
-        for layer in self.layers[1:4]:
-            for nid in layer:
-                if nid != 'C':
-                    self.nodes[nid]['x']   = np.zeros(d)
-                    self.nodes[nid]['vel'] = np.zeros(d)
-
-        c = self.nodes['C']
-        c['vel'] = np.zeros(d)
-
-        if self.mode == 'training' and c_target is not None:
-            c['x']        = np.asarray(c_target, dtype=float)[:d]
-            c['anchored'] = True
-            self.c_target = c['x'].copy()
-        else:
-            # Inference: C is free; store target only for accuracy measurement
-            c['anchored'] = False
-            c['x']        = np.zeros(d)
-            self.c_target = (np.asarray(c_target, dtype=float)[:d]
-                             if c_target is not None else None)
-
-    # ── FEEDFORWARD ───────────────────────────────────────────────────────────
-
-    def _forward(self):
-        """
-        Exact feedforward pass (used for learning).
-        Returns (C_pred, hidden_activations).
-        """
-        xa, xb = self.nodes['A']['x'], self.nodes['B']['x']
-        hid    = {}
-
-        for i in range(1, self.n_upper + 1):
-            uid = f'U{i}'
-            hid[uid] = self.K[('A', uid)] @ xa      # ℝ^d
-
-        for i in range(1, self.n_lower + 1):
-            lid = f'L{i}'
-            hid[lid] = self.K[('B', lid)] @ xb      # ℝ^d
-
-        pred = np.zeros(self.dim)
-        for i in range(1, self.n_upper + 1):
-            pred += self.K[(f'U{i}', 'C')] @ hid[f'U{i}']
-        for i in range(1, self.n_lower + 1):
-            pred += self.K[(f'L{i}', 'C')] @ hid[f'L{i}']
-
-        return pred, hid
-
-    # ── ELASTIC DISPLAY PHYSICS ───────────────────────────────────────────────
-
-    def _elastic_step(self, n_steps: int = MICRO):
-        """
-        Damped-oscillator spring dynamics for visualisation.
-
-        Forward springs pull hidden nodes toward their feedforward rest positions.
-        Backward tension (BACK_A) lets anchored-C's position propagate upstream —
-        the mesh physically feels the error as strain before any K update.
-        """
-        xa, xb = self.nodes['A']['x'], self.nodes['B']['x']
-
-        for _ in range(n_steps):
-            for i in range(1, self.n_upper + 1):
-                uid = f'U{i}'
-                n   = self.nodes[uid]
-                rest = self.K[('A', uid)] @ xa
-                f    = FWD_K * (rest - n['x'])
-                f   += BACK_A * (self.K[(uid, 'C')].T @
-                                 (self.nodes['C']['x'] - self.K[(uid, 'C')] @ n['x']))
-                n['vel'] = n['vel'] * DAMPING + f * DT
-                n['x']  += n['vel'] * DT
-
-            for i in range(1, self.n_lower + 1):
-                lid = f'L{i}'
-                n   = self.nodes[lid]
-                rest = self.K[('B', lid)] @ xb
-                f    = FWD_K * (rest - n['x'])
-                f   += BACK_A * (self.K[(lid, 'C')].T @
-                                 (self.nodes['C']['x'] - self.K[(lid, 'C')] @ n['x']))
-                n['vel'] = n['vel'] * DAMPING + f * DT
-                n['x']  += n['vel'] * DT
-
-            c = self.nodes['C']
-            if not c['anchored']:
-                rest = np.zeros(self.dim)
-                for i in range(1, self.n_upper + 1):
-                    rest += self.K[(f'U{i}', 'C')] @ self.nodes[f'U{i}']['x']
-                for i in range(1, self.n_lower + 1):
-                    rest += self.K[(f'L{i}', 'C')] @ self.nodes[f'L{i}']['x']
-                f = FWD_K * (rest - c['x'])
-                c['vel'] = c['vel'] * DAMPING + f * DT
-                c['x']  += c['vel'] * DT
-
-    # ── MATRIX LMS UPDATE ─────────────────────────────────────────────────────
-
-    def _lms_update(self, error: np.ndarray, hid: dict, ewc: bool = False):
-        """
-        Matrix LMS with joint optimal step.
-
-        For the output layer (X → C):
-          grad_K = outer(error, h_X)   ∈ ℝ^(d×d)
-          joint_denom = Σ_edges ‖h_X‖²   (one normaliser for all output-layer edges)
-          K(X,C) -= grad_K / joint_denom
-
-        This drives ‖error‖ → 0 in one step for linear systems (provable).
-
-        For the hidden layer (A/B → U/L):
-          delta propagates back through K(X,C):
-            δ_U = K(U,C)ᵀ @ error
-          grad_K = outer(δ_U, x_A)
-          K(A,U) -= grad_K / ‖x_A‖²
-
-        EWC mode: step size reduced by (1 + λ·F) per element, protecting
-        dimensions with high Fisher importance from past training.
-        """
-        eps  = 1e-8
-        xa   = self.nodes['A']['x']
-        xb   = self.nodes['B']['x']
-
-        # ── Output-layer joint update ──────────────────────────────────────
-        joint_denom = eps
-        for i in range(1, self.n_upper + 1):
-            joint_denom += float(np.dot(hid[f'U{i}'], hid[f'U{i}']))
-        for i in range(1, self.n_lower + 1):
-            joint_denom += float(np.dot(hid[f'L{i}'], hid[f'L{i}']))
-
-        for i in range(1, self.n_upper + 1):
-            uid = f'U{i}'
-            key = (uid, 'C')
-            grad = np.outer(error, hid[uid])
-            if ewc:
-                denom = joint_denom * (1.0 + EWC_LAMBDA * self.fisher[key])
-            else:
-                denom = joint_denom
-            self.K[key] -= grad / denom
-            np.clip(self.K[key], -8.0, 8.0, out=self.K[key])
-
-        for i in range(1, self.n_lower + 1):
-            lid = f'L{i}'
-            key = (lid, 'C')
-            grad = np.outer(error, hid[lid])
-            if ewc:
-                denom = joint_denom * (1.0 + EWC_LAMBDA * self.fisher[key])
-            else:
-                denom = joint_denom
-            self.K[key] -= grad / denom
-            np.clip(self.K[key], -8.0, 8.0, out=self.K[key])
-
-        # ── Hidden-layer update (backprop) ────────────────────────────────
-        xa_denom = float(np.dot(xa, xa)) + eps
-        xb_denom = float(np.dot(xb, xb)) + eps
-
-        for i in range(1, self.n_upper + 1):
-            uid  = f'U{i}'
-            key  = ('A', uid)
-            delta = self.K[(uid, 'C')].T @ error   # back-propagated error ∈ ℝ^d
-            grad  = np.outer(delta, xa)
-            if ewc:
-                denom = xa_denom * (1.0 + EWC_LAMBDA * self.fisher[key])
-            else:
-                denom = xa_denom
-            self.K[key] -= grad / denom
-            np.clip(self.K[key], -8.0, 8.0, out=self.K[key])
-
-        for i in range(1, self.n_lower + 1):
-            lid  = f'L{i}'
-            key  = ('B', lid)
-            delta = self.K[(lid, 'C')].T @ error
-            grad  = np.outer(delta, xb)
-            if ewc:
-                denom = xb_denom * (1.0 + EWC_LAMBDA * self.fisher[key])
-            else:
-                denom = xb_denom
-            self.K[key] -= grad / denom
-            np.clip(self.K[key], -8.0, 8.0, out=self.K[key])
-
-    # ── FISHER ACCUMULATION (EWC) ─────────────────────────────────────────────
-
-    def _update_fisher(self, error: np.ndarray, hid: dict):
-        """
-        Accumulate Fisher diagonal via EMA of squared gradient elements.
-        High Fisher → this weight dimension was important for past problems.
-        """
-        xa = self.nodes['A']['x']
-        xb = self.nodes['B']['x']
-
-        for i in range(1, self.n_upper + 1):
-            uid = f'U{i}'
-            g_uc = np.outer(error, hid[uid]) ** 2
-            g_au = np.outer(self.K[(uid, 'C')].T @ error, xa) ** 2
-            self.fisher[(uid, 'C')] = (FISHER_DECAY * self.fisher[(uid, 'C')] +
-                                       (1 - FISHER_DECAY) * g_uc)
-            self.fisher[('A', uid)] = (FISHER_DECAY * self.fisher[('A', uid)] +
-                                       (1 - FISHER_DECAY) * g_au)
-
-        for i in range(1, self.n_lower + 1):
-            lid = f'L{i}'
-            g_lc = np.outer(error, hid[lid]) ** 2
-            g_bl = np.outer(self.K[(lid, 'C')].T @ error, xb) ** 2
-            self.fisher[(lid, 'C')] = (FISHER_DECAY * self.fisher[(lid, 'C')] +
-                                       (1 - FISHER_DECAY) * g_lc)
-            self.fisher[('B', lid)] = (FISHER_DECAY * self.fisher[('B', lid)] +
-                                       (1 - FISHER_DECAY) * g_bl)
-
-    # ── PHYSICS STEP ──────────────────────────────────────────────────────────
-
-    def physics_step(self) -> bool:
-        """One server tick: elastic display + LMS update."""
-        self._elastic_step(MICRO)
-
-        pred, hid = self._forward()
-        self.pred_norm  = float(np.linalg.norm(pred))
-        self.step_count += 1
-
-        c = self.nodes['C']
-        if c['anchored']:
-            error           = pred - c['x']
-            self.error_norm = float(np.linalg.norm(error))
-        else:
-            c['x']          = pred.copy()
-            error           = (pred - self.c_target
-                               if self.c_target is not None
-                               else np.zeros(self.dim))
-            self.error_norm = float(np.linalg.norm(error))
-
-        self.history.append(round(self.error_norm, 5))
-        if len(self.history) > 300:
-            self.history.pop(0)
-
-        converged = self.error_norm < CONV_THRESH
-        timeout   = self.step_count >= MAX_STEPS
-
-        if converged or timeout:
-            tag = '✓' if converged else '⚠'
-            self.add_log(f"{tag} [{self.current_type}] "
-                         f"err={self.error_norm:.4f}  it={self.step_count}")
-            if self.mode == 'inference' and self.c_target is not None:
-                ct_norm = float(np.linalg.norm(self.c_target)) + 1e-8
-                self.test_errors.append({
-                    'type': self.current_type,
-                    'abs':  round(self.error_norm, 5),
-                    'rel':  round(self.error_norm / ct_norm, 5),
-                    'ok':   converged,
-                })
-            self._update_fisher(error, hid)
-            return self._next_or_stop()
-
-        if c['anchored']:
-            # Training: update K to reduce error
-            self._lms_update(error, hid, ewc=False)
-        elif self.mode == 'inference':
-            # Inference: EWC-regularised online adaptation
-            self._lms_update(error, hid, ewc=True)
-
-        self.iteration += 1
-        return True
-
-    def _next_or_stop(self) -> bool:
-        if self.batch_queue:
-            p = self.batch_queue.popleft()
-            self.set_problem(p['A'], p['B'], p.get('C'), p.get('type', 'unknown'))
-            return True
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+DIM = 8          # The actual width of the A, C, and B rows!
+LR = 0.05
+EWC_LAMBDA = 0.8
+FISHER_DECAY = 0.95
+DAMPING = 0.6    
+DT = 0.2
+
+# --- DATA GENERATOR (D-length arrays) ---
+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(f"Generating Scalar Fabric Dataset (D={DIM})...")
+    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)
+        
+        # 1. Straight blend (Dimension N only talks to Dimension N)
+        data.append({'a': a.tolist(), 'b': b.tolist(), 'c': (0.7 * a + 0.3 * b).tolist(), 'type': 'blend'})
+        
+        # 2. Difference (Requires repulsive negative springs)
+        data.append({'a': a.tolist(), 'b': b.tolist(), 'c': (0.5 + 0.4 * (a - b)).tolist(), 'type': 'diff'})
+        
+        # 3. Lateral Route (Dimension N talks to N-1 and N+1. Forces lateral springs to activate!)
+        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()
+
+# --- SCALAR FABRIC TOPOLOGY ---
+def _widths(d):
+    # e.g., D=8 -> 8, 9, 10, 9, 8(C), 9, 10, 9, 8
+    return [d, d+1, d+2, d+1, d, d+1, d+2, d+1, d]
+
+def _xpos(w):
+    # Offsets rows by 0.5 to create flawless equilateral triangles
+    return [(2*i - (w-1)) / 2.0 for i in range(w)]
+
+class ScalarFabricMesh:
+    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 = _widths(self.n_dim)
+        y_spacing = 0.866 
+        
+        # 1. Place individual scalar nodes
+        for r, w in enumerate(self.row_widths):
+            y = -r * y_spacing
+            xs = _xpos(w)
+            
+            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}"
+                self.nodes[nid] = {
+                    'x': 0.5, 'vel': 0.0, 'kind': kind, 'row': r, 'col': c,
+                    'pos': (xs[c], y), 'anchored': kind in ['A', 'B']
+                }
+
+        # 2. Wire the Fabric
+        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]
+                r1, r2 = self.nodes[n1]['row'], self.nodes[n2]['row']
+                x1, x2 = self.nodes[n1]['pos'][0], self.nodes[n2]['pos'][0]
+                
+                # Connect if horizontally adjacent OR diagonally adjacent
+                if (r1 == r2 and abs(x1 - x2) == 1.0) or (abs(r1 - r2) == 1 and abs(x1 - x2) == 0.5):
+                    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]
+
+        # Sort so array indices map correctly 0 -> D
+        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):
+        """Pins the D scalar nodes at A and B to the input arrays."""
+        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.5
+                data['vel'] = 0.0
+
+    def settle(self, steps=30):
+        """Pure Hookean Physics on Scalars."""
+        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
+            
+            for nid, data in self.nodes.items():
+                if not data['anchored']:
+                    f = forces[nid] - (0.05 * (data['x'] - 0.5)) # Soft ground
+                    data['vel'] = data['vel'] * DAMPING + f * DT
+                    data['x'] += data['vel'] * DT
+                    # Absolute stability bounding
+                    data['x'] = max(-1.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'):
+        """Physical Backprop through the fabric threads."""
+        # 1. Measure error at the D center nodes
+        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. Diffuse error outwards based on spring thickness
+        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
+            errors = next_err
+
+        # 3. Widrow-Hoff Local Thread Update
+        for key in self.springs:
+            u, v = key
+            
+            # THE CRITICAL SIGN CORRECTION (+). 
+            # If U is too high, and U pulls V, K must decrease to drop tension.
+            err_gradient = (errors[u] - errors[v]) * (self.nodes[u]['x'] - self.nodes[v]['x'])
+            norm_mod = 1.0 / ((self.nodes[u]['x'] - self.nodes[v]['x'])**2 + 0.1)
+            
+            step = LR * err_gradient * norm_mod
+            
+            if mode == 'train':
+                self.springs[key] += step
+                self.fisher[key] = FISHER_DECAY * self.fisher[key] + (1 - FISHER_DECAY) * (err_gradient ** 2)
+            elif mode == 'infer':
+                # EWC preserves memory of past geometries
+                penalty = EWC_LAMBDA * self.fisher[key] * (self.springs[key] - self.anchor_k[key])
+                self.springs[key] += (step * 0.2) - penalty
+                
+            self.springs[key] = max(-2.0, min(3.0, self.springs[key]))
+
+    def save_anchors(self):
+        self.anchor_k = dict(self.springs)
+
+class Engine:
+    def __init__(self):
+        self.mesh = ScalarFabricMesh()
+        self.mode = 'idle'
         self.running = False
-        self.add_log("◼ Queue empty.")
-        return 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 = []
 
-    # ── FAST OFFLINE TRAINING ─────────────────────────────────────────────────
+    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':
+            err = float(np.mean(np.abs(np.array(preds) - np.array(sample['c']))))
+            if math.isnan(err): err = 1.0 
+            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})
+
+            self.mesh.lms_update(sample['c'], mode=self.mode)
+        else:
+            self.current_err = 0.0
+        
+        self.iter += 1
+        if self.iter % 5 == 0 or sample['type'] == 'manual':
+            self.add_log(f"[{self.current_type}] err: {self.current_err:.4f}")
 
-    def train_offline(self, epochs: int = 5):
-        """
-        Run full training at CPU speed (no sleep, no display physics).
-        Called in a background thread from /train_offline endpoint.
-        """
+    def train_offline(self, epochs):
         self.running = False
-        self.mode    = 'training'
-        self.add_log(f"⚡ Offline training: {epochs} epoch(s)…")
-
-        for ep in range(1, epochs + 1):
+        self.mode = 'train'
+        self.add_log(f"⚡ Offline Training: {epochs} epochs...")
+        for ep in range(epochs):
             random.shuffle(self.train_data)
-            total_err = 0.0
-            converged = 0
-
+            errs = []
             for sample in self.train_data:
-                d = self.dim
-                xa = np.asarray(sample['A'], dtype=float)[:d]
-                xb = np.asarray(sample['B'], dtype=float)[:d]
-                ct = np.asarray(sample['C'], dtype=float)[:d]
-                self.nodes['A']['x'] = xa
-                self.nodes['B']['x'] = xb
-                self.nodes['C']['x'] = ct
-
-                for _ in range(MAX_STEPS):
-                    pred, hid = self._forward()
-                    err = pred - ct
-                    en  = float(np.linalg.norm(err))
-                    if en < CONV_THRESH:
-                        self._update_fisher(err, hid)
-                        converged += 1
-                        break
-                    self._lms_update(err, hid, ewc=False)
-
-                total_err += float(np.linalg.norm(self._forward()[0] - ct))
-
-            avg = total_err / max(len(self.train_data), 1)
-            pct = 100 * converged / max(len(self.train_data), 1)
-            self.add_log(f"  Ep {ep}/{epochs}: avg‖e‖={avg:.4f}  conv={pct:.1f}%")
-            print(f"  Ep {ep}/{epochs}: avg‖e‖={avg:.4f}  converged={pct:.1f}%")
-
-        # Save anchor weights for EWC
-        self.K_anchor = {k: v.copy() for k, v in self.K.items()}
-        self.add_log("✓ Offline training complete. EWC anchors saved.")
+                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}")
+            
+        self.mesh.save_anchors()
+        self.add_log("✓ Training Complete.")
         self.mode = 'idle'
 
-    # ── DATA LOADING ──────────────────────────────────────────────────────────
-
-    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)
-        self.add_log(f"Data loaded: {len(self.train_data)} train / "
-                     f"{len(self.test_data)} test")
-
-    # ── QUEUE HELPERS ─────────────────────────────────────────────────────────
-
-    def start_training(self, n=None):
-        data = random.sample(self.train_data,
-                             min(n or len(self.train_data), len(self.train_data)))
-        self._fill_queue(data, anchor_c=True)
-        self.mode    = 'training'
-        self.running = True
-        self.add_log(f"▶ Visual training: {len(data)} samples")
-
-    def start_inference(self, n=None):
-        data = self.test_data[:n] if n else self.test_data
-        self.test_errors = []
-        self._fill_queue(data, anchor_c=False)
-        self.mode    = 'inference'
-        self.running = True
-        self.add_log(f"▶ Inference: {len(data)} samples")
-
-    def _fill_queue(self, data, anchor_c):
-        self.batch_queue.clear()
-        for d in data:
-            self.batch_queue.append(
-                {'A': d['A'], 'B': d['B'], 'C': d['C'], 'type': d.get('type','?')}
-            )
-        if self.batch_queue:
-            p = self.batch_queue.popleft()
-            if anchor_c:
-                self.set_problem(p['A'], p['B'], p['C'], p['type'])
-            else:
-                # Inference: don't anchor but store target
-                d = self.dim
-                self.nodes['A']['x']       = np.asarray(p['A'])[:d]
-                self.nodes['B']['x']       = np.asarray(p['B'])[:d]
-                self.nodes['C']['x']       = np.zeros(d)
-                self.nodes['C']['vel']     = np.zeros(d)
-                self.nodes['C']['anchored'] = False
-                self.c_target              = np.asarray(p['C'])[:d]
-                self.current_type          = p['type']
-                self.step_count            = 0
-                for layer in self.layers[1:4]:
-                    for nid in layer:
-                        if nid != 'C':
-                            self.nodes[nid]['x']   = np.zeros(d)
-                            self.nodes[nid]['vel'] = np.zeros(d)
-
-    # ── LOGGING ───────────────────────────────────────────────────────────────
-
-    def add_log(self, msg):
-        self.logs.insert(0, f"[{self.iteration:06d}] {msg}")
-        if len(self.logs) > 60:
-            self.logs.pop()
-
-    # ── STATE SERIALISATION ───────────────────────────────────────────────────
-
-    def state_dict(self):
-        nodes_out = {}
-        for nid, n in self.nodes.items():
-            nodes_out[nid] = {
-                'norm':     round(float(np.linalg.norm(n['x'])),   4),
-                'vel_norm': round(float(np.linalg.norm(n['vel'])), 4),
-                'anchored': bool(n['anchored']),
-                'x_head':   [round(float(v), 3) for v in n['x'][:6]],
-            }
-
-        springs_out = {}
-        for (u, v), km in self.K.items():
-            label = f"{u}→{v}"
-            springs_out[label] = {
-                'frob': round(float(np.linalg.norm(km)), 4),
-                'mean': round(float(np.mean(km)),        4),
-                'std':  round(float(np.std(km)),         4),
-                'fish': round(float(np.mean(self.fisher[(u, v)])), 5),
-            }
-
-        # Per-type inference accuracy
-        type_acc = {}
-        for te in self.test_errors:
-            t = te['type']
-            if t not in type_acc:
-                type_acc[t] = {'n': 0, 'n_ok': 0, 'sum_abs': 0.0}
-            type_acc[t]['n']       += 1
-            type_acc[t]['n_ok']    += int(te['ok'])
-            type_acc[t]['sum_abs'] += te['abs']
-        acc_summary = {
-            t: {
-                'n':      v['n'],
-                'acc':    round(100 * v['n_ok'] / max(v['n'], 1), 1),
-                'avg_err': round(v['sum_abs'] / max(v['n'], 1), 4),
-            }
-            for t, v in type_acc.items()
-        }
-
-        return {
-            'nodes':        nodes_out,
-            'springs':      springs_out,
-            'error':        round(self.error_norm, 5),
-            'pred_norm':    round(self.pred_norm,  5),
-            'iter':         self.iteration,
-            'step_count':   self.step_count,
-            'logs':         self.logs,
-            'history':      self.history[-120:],
-            'running':      self.running,
-            'mode':         self.mode,
-            'n_upper':      self.n_upper,
-            'n_lower':      self.n_lower,
-            'layers':       self.layers,
-            'queue_size':   len(self.batch_queue),
-            'train_size':   len(self.train_data),
-            'test_size':    len(self.test_data),
-            'type_acc':     acc_summary,
-            'n_test_done':  len(self.test_errors),
-            'current_type': self.current_type,
-            'dim':          self.dim,
-        }
-
-
-# ── SERVER ────────────────────────────────────────────────────────────────────
-
-engine = MeshEngine(dim=DIM, n_upper=3, n_lower=3)
+    def get_accuracy_summary(self):
+        acc = {}
+        for r in self.test_results:
+            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()}
 
+engine = Engine()
 try:
-    engine.load_data()
+    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"No data found — run: python data_gen.py  ({e})")
+    engine.add_log(f"Error loading data: {str(e)}")
 
-
-def run_loop():
+def loop():
     while True:
-        if engine.running:
-            engine.physics_step()
-        time.sleep(0.025)
-
-threading.Thread(target=run_loop, daemon=True).start()
-
+        if engine.running: engine.run_step()
+        time.sleep(0.06)
+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()
-
-# ── Training controls ─────────────────────────────────────────────────────────
-
-@app.post("/train_visual")
-async def train_visual(data: dict = {}):
-    """Start visual (slow) training — shows elastic dynamics in UI."""
-    engine.start_training(n=data.get('n'))
+async def state():
+    return {
+        'nodes': engine.mesh.nodes,
+        # Safely pipe the tuples for JSON
+        '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))
+    threading.Thread(target=engine.train_offline, args=(ep,), daemon=True).start()
     return {"ok": True}
 
-@app.post("/train_offline")
-async def train_offline(data: dict = {}):
-    """Fast offline training in background thread — no display."""
-    epochs = int(data.get('epochs', 5))
-    threading.Thread(target=engine.train_offline, args=(epochs,), daemon=True).start()
-    return {"ok": True, "epochs": epochs}
-
 @app.post("/infer")
-async def start_infer(data: dict = {}):
-    """Run inference on test set, measuring C reconstruction accuracy."""
-    engine.start_inference(n=data.get('n'))
+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}
 
-@app.post("/reload_data")
-async def reload_data():
+@app.post("/manual")
+async def manual(data: dict):
     try:
-        engine.load_data()
+        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)}
 
-# ── Topology controls ────────────────────────────────────────────────────────
-
-@app.post("/set_layer")
-async def set_layer(data: dict):
-    layer = data.get('layer', '')
-    delta = int(data.get('delta', 0))
-    engine.running = False
-    if layer == 'upper':
-        engine.n_upper = max(1, min(8, engine.n_upper + delta))
-    elif layer == 'lower':
-        engine.n_lower = max(1, min(8, engine.n_lower + delta))
-    engine._init_mesh()
-    engine.add_log(f"Topology → U{engine.n_upper} · L{engine.n_lower} | springs re-init")
-    return {"ok": True, "n_upper": engine.n_upper, "n_lower": engine.n_lower}
-
 @app.post("/halt")
-async def halt():
-    engine.running = False
-    return {"ok": True}
-
-@app.post("/reset")
-async def reset():
-    engine.running = False
-    engine._init_mesh()
-    engine.add_log("Mesh reset.")
-    return {"ok": True}
-
+async def halt(): engine.running = False; return {"ok": True}
 
 if __name__ == "__main__":
     import uvicorn