Update app.py

app.py

@@ -1,5 +1,4 @@
-import numpy as np
-import time, collections, threading, json, random, math, os, pathlib
+import time, collections, threading, random
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
@@ -7,321 +6,428 @@ from fastapi.middleware.cors import CORSMiddleware
 app = FastAPI()
 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
+# ── ELASTIC CONSTANTS ─────────────────────────────────────────────────────────
+FWD_K   = 2.2    # spring pull toward rest position
+DAMPING = 0.55   # velocity retention (lower = more visible oscillation)
+DT      = 0.12   # micro-step size
+MICRO   = 6      # micro-steps per physics_step (keeps UI responsive)
+SETTLE  = 0.004  # velocity threshold for early exit
+
+
+class SimEngine:
+    def __init__(self):
+        self.mode         = 'training'
+        self.architecture = 'additive'
+        self.dataset_type = 'housing'
+        self.n_upper      = 3      # nodes in upper bulge (A-side)
+        self.n_lower      = 3      # nodes in lower bulge (B-side)
+        self.back_alpha   = 0.45   # backward tension coupling
+        self.running      = False
+        self.batch_queue  = collections.deque()
+        self.logs         = []
+        self.iteration    = 0
+        self.current_error      = 0.0
+        self.current_prediction = 0.0
+        self.history            = []
+        self._init_mesh()
+
+    # ── TOPOLOGY ──────────────────────────────────────────────────────────────
+    # Physical layout (top→bottom):
+    #   A  → U1..Un → C ← L1..Ln ← B
+    #
+    # Layers for display (top to bottom):
+    #   0: [A]
+    #   1: [U1..Un]   upper bulge
+    #   2: [C]        CENTER — the waist
+    #   3: [L1..Ln]   lower bulge
+    #   4: [B]
+    #
+    # Springs:
+    #   A  → each Ui   (K_aui)
+    #   Ui → C         (K_uic)
+    #   B  → each Li   (K_bli)
+    #   Li → C         (K_lic)
+
+    def _build_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.current_error      = 0.0
+        self.current_prediction = 0.0
+        self.history            = []
+        self.layers             = self._build_layers()
+
         self.nodes = {}
+        for layer in self.layers:
+            for nid in layer:
+                anchored = nid in ('A', 'B')
+                self.nodes[nid] = {'x': 0.0, 'vel': 0.0, 'anchored': anchored}
+        self.nodes['A']['x'] = 2.0
+        self.nodes['B']['x'] = 3.0
+
+        # Springs — one per directed edge
         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'
+        # A-side: A → Ui → C
+        for i in range(1, self.n_upper + 1):
+            uid = f'U{i}'
+            self.springs[('A',  uid)] = round(random.uniform(0.85, 1.15), 4)
+            self.springs[(uid, 'C')] = round(random.uniform(0.85, 1.15), 4)
+        # B-side: B → Li → C
+        for i in range(1, self.n_lower + 1):
+            lid = f'L{i}'
+            self.springs[('B',  lid)] = round(random.uniform(0.85, 1.15), 4)
+            self.springs[(lid, 'C')] = round(random.uniform(0.85, 1.15), 4)
+
+    def reset(self):
         self.running = False
-        self.queue = collections.deque()
+        self.batch_queue.clear()
         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 = []
+        self._init_mesh()
 
+    # ── LOGGING ───────────────────────────────────────────────────────────────
     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)
+        self.logs.insert(0, f"[{self.iteration:04d}] {msg}")
+        if len(self.logs) > 40:
+            self.logs.pop()
+
+    # ── DATASET ───────────────────────────────────────────────────────────────
+    def ground_truth(self, a, b):
+        t = self.dataset_type
+        if   t == 'housing':        return round(a * 2.5 + b * 1.2, 4)
+        elif t == 'subtraction':    return round(a - b,              4)
+        elif t == 'multiplication': return round(a * b,              4)
+        elif t == 'quadratic':      return round(a * a + b,          4)
+        return round(a + b, 4)
+
+    # ── PROBLEM SETUP ─────────────────────────────────────────────────────────
+    def set_problem(self, a, b, c_target=None):
+        self.nodes['A']['x'] = float(a)
+        self.nodes['B']['x'] = float(b)
+        # Reset hidden nodes so elastic wave is visible from scratch
+        for layer in self.layers[1:4]:
+            for nid in layer:
+                if nid != 'C':
+                    self.nodes[nid]['x']   = 0.0
+                    self.nodes[nid]['vel'] = 0.0
+        c = self.nodes['C']
+        c['vel'] = 0.0
+        if self.mode == 'training' and c_target is not None:
+            c['x']        = float(c_target)
+            c['anchored'] = True
         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):
+            c['anchored'] = False
+            c['x']        = 0.0
+
+    # ── FEEDFORWARD REST POSITION ─────────────────────────────────────────────
+    def _rest_upper(self, uid):
+        """Rest position of an upper hidden node — driven by A."""
+        k = self.springs[('A', uid)]
+        xa = self.nodes['A']['x']
+        return k * xa  # additive or used as scale for mult
+
+    def _rest_lower(self, lid):
+        """Rest position of a lower hidden node — driven by B."""
+        k = self.springs[('B', lid)]
+        xb = self.nodes['B']['x']
+        return k * xb
+
+    def _rest_c(self):
+        """Rest position of C — sum of contributions from both bulges."""
+        total = 0.0
+        for i in range(1, self.n_upper + 1):
+            uid = f'U{i}'
+            hu  = self.nodes[uid]['x']
+            total += self.springs[(uid, 'C')] * hu
+        for i in range(1, self.n_lower + 1):
+            lid = f'L{i}'
+            hl  = self.nodes[lid]['x']
+            total += self.springs[(lid, 'C')] * hl
+        return total
+
+    # ── ELASTIC RELAXATION (DISPLAY PHYSICS) ─────────────────────────────────
+    def _elastic_step(self, n_steps):
+        """
+        Damped-oscillator spring dynamics for visualisation.
+
+        Upper hidden nodes Ui are pulled toward K(A,Ui)·A by a forward spring.
+        Lower hidden nodes Li are pulled toward K(B,Li)·B by a forward spring.
+        C is pulled toward Σ K(Xi,C)·Xi from both sides.
+
+        Back-tension (alpha): if alpha>0, each node also feels a restoring pull
+        from downstream — i.e. C's anchored position creates tension that travels
+        back up through Ui and down through Li, making the elastic wave visible.
+        """
+        alpha = self.back_alpha
+        for _ in range(n_steps):
+            max_v = 0.0
+
+            # Upper hidden nodes
+            for i in range(1, self.n_upper + 1):
+                uid = f'U{i}'
+                n   = self.nodes[uid]
+                f   = FWD_K * (self._rest_upper(uid) - n['x'])
+                if alpha > 0:
+                    kuc = self.springs[(uid, 'C')]
+                    f  += alpha * kuc * (self.nodes['C']['x'] - n['x'])
+                n['vel']  = n['vel'] * DAMPING + f * DT
+                n['x']   += n['vel'] * DT
+                max_v     = max(max_v, abs(n['vel']))
+
+            # Lower hidden nodes
+            for i in range(1, self.n_lower + 1):
+                lid = f'L{i}'
+                n   = self.nodes[lid]
+                f   = FWD_K * (self._rest_lower(lid) - n['x'])
+                if alpha > 0:
+                    klc = self.springs[(lid, 'C')]
+                    f  += alpha * klc * (self.nodes['C']['x'] - n['x'])
+                n['vel']  = n['vel'] * DAMPING + f * DT
+                n['x']   += n['vel'] * DT
+                max_v     = max(max_v, abs(n['vel']))
+
+            # C node (only moves in inference)
+            c = self.nodes['C']
+            if not c['anchored']:
+                f         = FWD_K * (self._rest_c() - c['x'])
+                c['vel']  = c['vel'] * DAMPING + f * DT
+                c['x']   += c['vel'] * DT
+                max_v     = max(max_v, abs(c['vel']))
+
+            if max_v < SETTLE:
+                break
+
+    # ── EXACT FEEDFORWARD (LEARNING) ─────────────────────────────────────────
+    def _feedforward(self):
+        """
+        Exact prediction, independent of elastic node positions.
+        Additive:       Ui = K(A,Ui)·A   Li = K(B,Li)·B
+        Multiplicative: same shape but U·L cross-product at C boundary.
+        Returns (prediction, hidden_values_dict).
+        """
+        A, B = self.nodes['A']['x'], self.nodes['B']['x']
+        ff   = {}
+
+        for i in range(1, self.n_upper + 1):
+            uid       = f'U{i}'
+            ff[uid]   = self.springs[('A', uid)] * A
+
+        for i in range(1, self.n_lower + 1):
+            lid       = f'L{i}'
+            ff[lid]   = self.springs[('B', lid)] * B
+
+        if self.architecture == 'multiplicative':
+            # Each Ui pairs with a Li (by index, wrap if unequal counts)
+            pred = 0.0
+            n    = max(self.n_upper, self.n_lower)
+            for i in range(n):
+                uid  = f'U{(i % self.n_upper) + 1}'
+                lid  = f'L{(i % self.n_lower) + 1}'
+                ku   = self.springs[(uid, 'C')]
+                kl   = self.springs[(lid, 'C')]
+                pred += ku * ff[uid] * kl * ff[lid]
+        else:
+            # Additive: both sides simply sum at C
+            pred = (
+                sum(self.springs[(f'U{i}', 'C')] * ff[f'U{i}'] for i in range(1, self.n_upper + 1)) +
+                sum(self.springs[(f'L{i}', 'C')] * ff[f'L{i}'] for i in range(1, self.n_lower + 1))
+            )
+
+        return pred, ff
+
+    # ── LMS OPTIMAL-STEP UPDATE ───────────────────────────────────────────────
+    def _lms_update(self, error, ff):
+        """
+        LMS optimal step μ = error / ||∇pred||²
+        Gradients via backprop through feedforward values.
+        """
+        grads = {k: 0.0 for k in self.springs}
+        A, B  = self.nodes['A']['x'], self.nodes['B']['x']
+
+        if self.architecture == 'additive':
+            for i in range(1, self.n_upper + 1):
+                uid = f'U{i}'
+                kau = self.springs[('A', uid)]
+                kuc = self.springs[(uid, 'C')]
+                # ∂pred/∂K(A,Ui) = K(Ui,C)·A
+                grads[('A', uid)] = kuc * A
+                # ∂pred/∂K(Ui,C) = K(A,Ui)·A
+                grads[(uid, 'C')] = kau * A
+            for i in range(1, self.n_lower + 1):
+                lid = f'L{i}'
+                kbl = self.springs[('B', lid)]
+                klc = self.springs[(lid, 'C')]
+                grads[('B', lid)] = klc * B
+                grads[(lid, 'C')] = kbl * B
+        else:
+            n = max(self.n_upper, self.n_lower)
+            for i in range(n):
+                uid  = f'U{(i % self.n_upper) + 1}'
+                lid  = f'L{(i % self.n_lower) + 1}'
+                kau  = self.springs[('A', uid)]
+                kbl  = self.springs[('B', lid)]
+                ku   = self.springs[(uid, 'C')]
+                kl   = self.springs[(lid, 'C')]
+                Uv, Lv = ff[uid], ff[lid]
+                # ∂pred/∂K(A,Ui) = K(Ui,C)·A · K(Li,C)·Lv
+                grads[('A', uid)]  = ku * A * kl * Lv
+                grads[('B', lid)]  = kl * B * ku * Uv
+                grads[(uid, 'C')]  = Uv * kl * Lv
+                grads[(lid, 'C')]  = Lv * ku * Uv
+
+        norm_sq = sum(g * g for g in grads.values()) + 1e-10
+        mu = error / norm_sq
+        for key, g in grads.items():
+            self.springs[key] -= mu * g
+            self.springs[key]  = max(-30.0, min(30.0, self.springs[key]))
+
+    # ── MAIN PHYSICS STEP ─────────────────────────────────────────────────────
+    def physics_step(self):
+        self._elastic_step(MICRO)
+
+        pred, ff            = self._feedforward()
+        self.current_prediction = round(pred, 5)
+
+        c = self.nodes['C']
+        if c['anchored']:
+            self.current_error = pred - c['x']
+        else:
+            c['x']             = round(pred, 4)
+            self.current_error = 0.0
+
+        self.history.append(round(self.current_error, 4))
+        if len(self.history) > 200:
+            self.history.pop(0)
+
+        if abs(self.current_error) < 0.02:
+            a, b = self.nodes['A']['x'], self.nodes['B']['x']
+            gt   = self.ground_truth(a, b)
+            self.add_log(
+                f"✓ A={a:.2f} B={b:.2f} → P={pred:.4f} GT={gt:.4f} Δ={abs(pred-gt):.4f}"
+            )
+            return self._next_or_stop()
+
+        if self.mode == 'training' and c['anchored']:
+            self._lms_update(self.current_error, ff)
+
+        self.iteration += 1
+        return True
+
+    def _next_or_stop(self):
+        if self.batch_queue:
+            p = self.batch_queue.popleft()
+            self.set_problem(p['a'], p['b'], p.get('c'))
+            self.add_log(f"→ Next ({len(self.batch_queue)} queued)")
+            return True
         self.running = False
-        self.mode = 'train'
-        self.add_log(f"⚡ Offline Training: {epochs} epochs...")
-        for ep in range(epochs):
-            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}")
-            
-        self.mesh.save_anchors()
-        self.add_log("✓ Training Complete.")
-        self.mode = 'idle'
-
-    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:
-    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():
+        self.add_log("◼ Batch complete.")
+        return False
+
+    def generate_batch(self, count=30):
+        self.batch_queue.clear()
+        for _ in range(count):
+            a = round(random.uniform(1.0, 10.0), 2)
+            b = round(random.uniform(1.0, 10.0), 2)
+            self.batch_queue.append({'a': a, 'b': b, 'c': self.ground_truth(a, b)})
+        p = self.batch_queue.popleft()
+        self.set_problem(p['a'], p['b'], p.get('c'))
+        self.running = True
+        self.add_log(f"▶ {count} samples | {self.dataset_type} | U{self.n_upper}·L{self.n_lower}")
+
+
+# ── SERVER ────────────────────────────────────────────────────────────────────
+engine = SimEngine()
+
+def run_loop():
     while True:
-        if engine.running: engine.run_step()
-        time.sleep(0.06)
-threading.Thread(target=loop, daemon=True).start()
+        if engine.running:
+            engine.physics_step()
+        time.sleep(0.028)
+
+threading.Thread(target=run_loop, daemon=True).start()
 
 @app.get("/", response_class=HTMLResponse)
-async def ui(): return FileResponse("index.html")
+async def get_ui():
+    return FileResponse("index.html")
 
 @app.get("/state")
-async def state():
+async def get_state():
+    springs_out = {f"{u}→{v}": round(k, 5) for (u, v), k in engine.springs.items()}
     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
+        'nodes':        engine.nodes,
+        'springs':      springs_out,
+        'layers':       engine.layers,
+        'error':        engine.current_error,
+        'prediction':   engine.current_prediction,
+        'iter':         engine.iteration,
+        'logs':         engine.logs,
+        'history':      engine.history[-80:],
+        'running':      engine.running,
+        'mode':         engine.mode,
+        'architecture': engine.architecture,
+        'dataset_type': engine.dataset_type,
+        'n_upper':      engine.n_upper,
+        'n_lower':      engine.n_lower,
+        'back_alpha':   engine.back_alpha,
+        'queue_size':   len(engine.batch_queue),
     }
 
-@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()
+@app.post("/config")
+async def config(data: dict):
+    engine.mode         = data.get('mode',         engine.mode)
+    engine.architecture = data.get('architecture', engine.architecture)
+    engine.dataset_type = data.get('dataset',      engine.dataset_type)
+    engine.n_upper      = max(1, min(8, int(data.get('n_upper',    engine.n_upper))))
+    engine.n_lower      = max(1, min(8, int(data.get('n_lower',    engine.n_lower))))
+    engine.back_alpha   = max(0.0, min(1.0, float(data.get('back_alpha', engine.back_alpha))))
+    engine.running = False
+    engine._init_mesh()
+    engine.logs = []
+    engine.add_log(
+        f"Config: {engine.mode}|{engine.architecture}|U{engine.n_upper}·L{engine.n_lower}|α={engine.back_alpha:.2f}"
+    )
     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
+@app.post("/set_layer")
+async def set_layer(data: dict):
+    layer = data.get('layer', '')
+    delta = int(data.get('delta', 0))
+    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.running = False
+    engine._init_mesh()
+    engine.add_log(f"Topology → U{engine.n_upper}·L{engine.n_lower}")
+    return {"ok": True, "n_upper": engine.n_upper, "n_lower": engine.n_lower}
+
+@app.post("/generate")
+async def generate(data: dict):
+    engine.generate_batch(int(data.get('count', 30)))
     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("/run_custom")
+async def run_custom(data: dict):
+    a = float(data['a'])
+    b = float(data['b'])
+    c = float(data['c']) if data.get('c') not in (None, '', 'null') else None
+    if c is None and engine.mode == 'training':
+        c = engine.ground_truth(a, b)
+    engine.batch_queue.clear()
+    engine.set_problem(a, b, c)
+    engine.running = True
+    engine.add_log(f"Custom: A={a} B={b} target={c}")
+    return {"ok": True}
 
 @app.post("/halt")
-async def halt(): engine.running = False; return {"ok": True}
+async def halt():
+    engine.running = False
+    return {"ok": True}
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860)