Update app.py

app.py

@@ -7,11 +7,12 @@ app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
 # ── 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
+FWD_K   = 2.2
+DAMPING = 0.55
+DT      = 0.12
+MICRO   = 6
+SETTLE  = 0.004
+CONV_THRESH = 0.02
 
 
 class SimEngine:
@@ -19,9 +20,10 @@ class SimEngine:
         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.n_inputs     = 1      # ← number of input/output dimensions
+        self.n_upper      = 3      # hidden nodes per dim, A-side
+        self.n_lower      = 3      # hidden nodes per dim, B-side
+        self.back_alpha   = 0.45
         self.running      = False
         self.batch_queue  = collections.deque()
         self.logs         = []
@@ -32,29 +34,25 @@ class SimEngine:
         self._init_mesh()
 
     # ── TOPOLOGY ──────────────────────────────────────────────────────────────
-    # Physical layout (top→bottom):
-    #   A  → U1..Un → C ← L1..Ln ← B
+    # For n_inputs=N, n_upper=U, n_lower=L:
+    #   Layer 0 : [A1..AN]
+    #   Layer 1 : [U1_1..U1_U, U2_1..UN_U]   upper bulge, grouped by dim
+    #   Layer 2 : [C1..CN]                    center waist
+    #   Layer 3 : [L1_1..L1_L, L2_1..LN_L]   lower bulge
+    #   Layer 4 : [B1..BN]
     #
-    # 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)
+    # Springs per dimension d:
+    #   (Ad, Ud_j)  and  (Ud_j, Cd)  for j in 1..n_upper
+    #   (Bd, Ld_j)  and  (Ld_j, Cd)  for j in 1..n_lower
 
     def _build_layers(self):
+        n, nu, nl = self.n_inputs, self.n_upper, self.n_lower
         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'],
+            [f'A{d}'     for d in range(1, n+1)],
+            [f'U{d}_{j}' for d in range(1, n+1) for j in range(1, nu+1)],
+            [f'C{d}'     for d in range(1, n+1)],
+            [f'L{d}_{j}' for d in range(1, n+1) for j in range(1, nl+1)],
+            [f'B{d}'     for d in range(1, n+1)],
         ]
 
     def _init_mesh(self):
@@ -63,27 +61,28 @@ class SimEngine:
         self.current_prediction = 0.0
         self.history            = []
         self.layers             = self._build_layers()
+        n = self.n_inputs
 
         self.nodes = {}
         for layer in self.layers:
             for nid in layer:
-                anchored = nid in ('A', 'B')
+                anchored = nid[0] 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
+        for d in range(1, n+1):
+            self.nodes[f'A{d}']['x'] = 2.0
+            self.nodes[f'B{d}']['x'] = 3.0
+
         self.springs = {}
-        # 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)
+        for d in range(1, n+1):
+            for j in range(1, self.n_upper+1):
+                uid = f'U{d}_{j}'
+                self.springs[(f'A{d}', uid)]   = round(random.uniform(0.85, 1.15), 4)
+                self.springs[(uid,     f'C{d}')] = round(random.uniform(0.85, 1.15), 4)
+            for j in range(1, self.n_lower+1):
+                lid = f'L{d}_{j}'
+                self.springs[(f'B{d}', lid)]   = round(random.uniform(0.85, 1.15), 4)
+                self.springs[(lid,     f'C{d}')] = round(random.uniform(0.85, 1.15), 4)
 
     def reset(self):
         self.running = False
@@ -91,230 +90,238 @@ class SimEngine:
         self.logs = []
         self._init_mesh()
 
-    # ── LOGGING ───────────────────────────────────────────────────────────────
     def add_log(self, msg):
-        self.logs.insert(0, f"[{self.iteration:04d}] {msg}")
-        if len(self.logs) > 40:
+        self.logs.insert(0, f"[{self.iteration:05d}] {msg}")
+        if len(self.logs) > 50:
             self.logs.pop()
 
+    # ── HELPERS ───────────────────────────────────────────────────────────────
+
+    def _to_vec(self, val, n):
+        """Ensure val is a list of n floats. Scalars are broadcast."""
+        if isinstance(val, (list, tuple)):
+            v = [float(x) for x in val]
+            if len(v) >= n:
+                return v[:n]
+            return v + [v[-1]] * (n - len(v))
+        return [float(val)] * n
+
     # ── DATASET ───────────────────────────────────────────────────────────────
-    def ground_truth(self, a, b):
+
+    def ground_truth(self, a_vec, b_vec):
+        """Per-dimension ground truth. Same formula applied independently."""
+        n = self.n_inputs
+        a_vec = self._to_vec(a_vec, n)
+        b_vec = self._to_vec(b_vec, n)
         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)
+        result = []
+        for i in range(n):
+            a, b = a_vec[i], b_vec[i]
+            if   t == 'housing':        result.append(round(a * 2.5 + b * 1.2, 4))
+            elif t == 'subtraction':    result.append(round(a - b,              4))
+            elif t == 'multiplication': result.append(round(a * b,              4))
+            elif t == 'quadratic':      result.append(round(a*a + b,            4))
+            else:                       result.append(round(a + b,              4))
+        return result
 
     # ── 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:
-            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.
+    def set_problem(self, a, b, c_target=None):
+        n     = self.n_inputs
+        a_vec = self._to_vec(a, n)
+        b_vec = self._to_vec(b, n)
+
+        for d in range(1, n+1):
+            self.nodes[f'A{d}']['x'] = a_vec[d-1]
+            self.nodes[f'B{d}']['x'] = b_vec[d-1]
+
+        # Reset hidden nodes only
+        for nid, nd in self.nodes.items():
+            if nid[0] in ('U', 'L'):
+                nd['x'] = 0.0
+                nd['vel'] = 0.0
+
+        c_vec = self._to_vec(c_target, n) if c_target is not None else None
+        for d in range(1, n+1):
+            c = self.nodes[f'C{d}']
+            c['vel'] = 0.0
+            if self.mode == 'training' and c_vec is not None:
+                c['x']        = c_vec[d-1]
+                c['anchored'] = True
+            else:
+                c['anchored'] = False
+                c['x']        = 0.0
+
+    # ── ELASTIC DISPLAY PHYSICS ───────────────────────────────────────────────
 
-        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.
-        """
+    def _elastic_step(self, n_steps):
         alpha = self.back_alpha
+        n     = self.n_inputs
         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']))
+            for d in range(1, n+1):
+                A_val = self.nodes[f'A{d}']['x']
+                B_val = self.nodes[f'B{d}']['x']
+                C_val = self.nodes[f'C{d}']['x']
+
+                for j in range(1, self.n_upper+1):
+                    uid  = f'U{d}_{j}'
+                    nd   = self.nodes[uid]
+                    rest = self.springs[(f'A{d}', uid)] * A_val
+                    f    = FWD_K * (rest - nd['x'])
+                    if alpha > 0:
+                        kuc = self.springs[(uid, f'C{d}')]
+                        f  += alpha * kuc * (C_val - nd['x'])
+                    nd['vel'] = nd['vel'] * DAMPING + f * DT
+                    nd['x']  += nd['vel'] * DT
+                    max_v     = max(max_v, abs(nd['vel']))
+
+                for j in range(1, self.n_lower+1):
+                    lid  = f'L{d}_{j}'
+                    nd   = self.nodes[lid]
+                    rest = self.springs[(f'B{d}', lid)] * B_val
+                    f    = FWD_K * (rest - nd['x'])
+                    if alpha > 0:
+                        klc = self.springs[(lid, f'C{d}')]
+                        f  += alpha * klc * (C_val - nd['x'])
+                    nd['vel'] = nd['vel'] * DAMPING + f * DT
+                    nd['x']  += nd['vel'] * DT
+                    max_v     = max(max_v, abs(nd['vel']))
+
+                c = self.nodes[f'C{d}']
+                if not c['anchored']:
+                    rest_c = (
+                        sum(self.springs[(f'U{d}_{j}', f'C{d}')] * self.nodes[f'U{d}_{j}']['x']
+                            for j in range(1, self.n_upper+1)) +
+                        sum(self.springs[(f'L{d}_{j}', f'C{d}')] * self.nodes[f'L{d}_{j}']['x']
+                            for j in range(1, self.n_lower+1))
+                    )
+                    f         = FWD_K * (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) ─────────────────────────────────────────
+    # ── FEEDFORWARD ───────────────────────────────────────────────────────────
+
     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 ─────────────────────────────────────────────────────
+        n     = self.n_inputs
+        preds = []
+        ff    = {}
+        for d in range(1, n+1):
+            A_val = self.nodes[f'A{d}']['x']
+            B_val = self.nodes[f'B{d}']['x']
+
+            for j in range(1, self.n_upper+1):
+                uid       = f'U{d}_{j}'
+                ff[uid]   = self.springs[(f'A{d}', uid)] * A_val
+
+            for j in range(1, self.n_lower+1):
+                lid       = f'L{d}_{j}'
+                ff[lid]   = self.springs[(f'B{d}', lid)] * B_val
+
+            if self.architecture == 'multiplicative':
+                nm   = max(self.n_upper, self.n_lower)
+                pred = 0.0
+                for i in range(nm):
+                    uid  = f'U{d}_{(i % self.n_upper) + 1}'
+                    lid  = f'L{d}_{(i % self.n_lower) + 1}'
+                    ku   = self.springs[(uid, f'C{d}')]
+                    kl   = self.springs[(lid, f'C{d}')]
+                    pred += ku * ff[uid] * kl * ff[lid]
+            else:
+                pred = (
+                    sum(self.springs[(f'U{d}_{j}', f'C{d}')] * ff[f'U{d}_{j}']
+                        for j in range(1, self.n_upper+1)) +
+                    sum(self.springs[(f'L{d}_{j}', f'C{d}')] * ff[f'L{d}_{j}']
+                        for j in range(1, self.n_lower+1))
+                )
+            preds.append(pred)
+        return preds, ff
+
+    # ── LMS UPDATE ────────────────────────────────────────────────────────────
+
+    def _lms_update(self, errors, ff):
+        n = self.n_inputs
+        for d in range(1, n+1):
+            err   = errors[d-1]
+            A_val = self.nodes[f'A{d}']['x']
+            B_val = self.nodes[f'B{d}']['x']
+            grads = {}
+
+            if self.architecture == 'additive':
+                for j in range(1, self.n_upper+1):
+                    uid = f'U{d}_{j}'
+                    grads[(f'A{d}', uid)]   = self.springs[(uid,     f'C{d}')] * A_val
+                    grads[(uid,     f'C{d}')] = self.springs[(f'A{d}', uid)]   * A_val
+                for j in range(1, self.n_lower+1):
+                    lid = f'L{d}_{j}'
+                    grads[(f'B{d}', lid)]   = self.springs[(lid,     f'C{d}')] * B_val
+                    grads[(lid,     f'C{d}')] = self.springs[(f'B{d}', lid)]   * B_val
+            else:
+                nm = max(self.n_upper, self.n_lower)
+                for i in range(nm):
+                    uid = f'U{d}_{(i % self.n_upper) + 1}'
+                    lid = f'L{d}_{(i % self.n_lower) + 1}'
+                    ku  = self.springs[(uid, f'C{d}')]
+                    kl  = self.springs[(lid, f'C{d}')]
+                    Uv  = ff[uid]; Lv = ff[lid]
+                    grads[(f'A{d}', uid)]   = ku * A_val * kl * Lv
+                    grads[(f'B{d}', lid)]   = kl * B_val * ku * Uv
+                    grads[(uid,     f'C{d}')] = Uv * kl * Lv
+                    grads[(lid,     f'C{d}')] = Lv * ku * Uv
+
+            norm_sq = sum(g * g for g in grads.values()) + 1e-10
+            mu      = err / 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]))
+
+    # ── 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))
+        preds, ff = self._feedforward()
+        n         = self.n_inputs
+
+        errors = []
+        for d in range(1, n+1):
+            c = self.nodes[f'C{d}']
+            if c['anchored']:
+                errors.append(preds[d-1] - c['x'])
+            else:
+                c['x'] = round(preds[d-1], 4)
+                errors.append(0.0)
+
+        self.current_prediction = round(sum(preds) / n, 5)
+        self.current_error      = round(sum(abs(e) for e in errors) / n, 5)
+
+        self.history.append(self.current_error)
         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}"
-            )
+        if self.current_error < CONV_THRESH:
+            a_vec = [self.nodes[f'A{d}']['x'] for d in range(1, n+1)]
+            b_vec = [self.nodes[f'B{d}']['x'] for d in range(1, n+1)]
+            gt    = self.ground_truth(a_vec, b_vec)
+            delta = sum(abs(preds[d-1] - gt[d-1]) for d in range(1, n+1)) / n
+            if n == 1:
+                self.add_log(
+                    f"✓ A={a_vec[0]:.2f} B={b_vec[0]:.2f} "
+                    f"P={preds[0]:.4f} GT={gt[0]:.4f} Δ={delta:.4f}"
+                )
+            else:
+                p_str = ' '.join(f'{p:.3f}' for p in preds)
+                g_str = ' '.join(f'{g:.3f}' for g in gt)
+                self.add_log(f"✓ D={n} P=[{p_str}] GT=[{g_str}] Δ={delta:.4f}")
             return self._next_or_stop()
 
-        if self.mode == 'training' and c['anchored']:
-            self._lms_update(self.current_error, ff)
+        if self.mode == 'training' and any(
+            self.nodes[f'C{d}']['anchored'] for d in range(1, n+1)
+        ):
+            self._lms_update(errors, ff)
 
         self.iteration += 1
         return True
@@ -331,19 +338,25 @@ class SimEngine:
 
     def generate_batch(self, count=30):
         self.batch_queue.clear()
+        n = self.n_inputs
         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)})
+            a_vec = [round(random.uniform(1.0, 10.0), 2) for _ in range(n)]
+            b_vec = [round(random.uniform(1.0, 10.0), 2) for _ in range(n)]
+            c_vec = self.ground_truth(a_vec, b_vec)
+            self.batch_queue.append({'a': a_vec, 'b': b_vec, 'c': c_vec})
         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}")
+        self.add_log(
+            f"▶ {count} samples | {self.dataset_type} "
+            f"| D={n} U{self.n_upper}·L{self.n_lower}"
+        )
 
 
 # ── SERVER ────────────────────────────────────────────────────────────────────
 engine = SimEngine()
 
+
 def run_loop():
     while True:
         if engine.running:
@@ -352,19 +365,23 @@ def run_loop():
 
 threading.Thread(target=run_loop, daemon=True).start()
 
+
 @app.get("/", response_class=HTMLResponse)
 async def get_ui():
     return FileResponse("index.html")
 
+
 @app.get("/state")
 async def get_state():
     springs_out = {f"{u}→{v}": round(k, 5) for (u, v), k in engine.springs.items()}
+    n = engine.n_inputs
     return {
         'nodes':        engine.nodes,
         'springs':      springs_out,
         'layers':       engine.layers,
         'error':        engine.current_error,
         'prediction':   engine.current_prediction,
+        'predictions':  [round(engine.nodes[f'C{d}']['x'], 4) for d in range(1, n+1)],
         'iter':         engine.iteration,
         'logs':         engine.logs,
         'history':      engine.history[-80:],
@@ -372,62 +389,121 @@ async def get_state():
         'mode':         engine.mode,
         'architecture': engine.architecture,
         'dataset_type': engine.dataset_type,
+        'n_inputs':     n,
         'n_upper':      engine.n_upper,
         'n_lower':      engine.n_lower,
         'back_alpha':   engine.back_alpha,
         'queue_size':   len(engine.batch_queue),
     }
 
+
+@app.post("/set_mode")
+async def set_mode(data: dict):
+    """Switch training ↔ inference without touching springs or mesh."""
+    engine.mode    = data.get('mode', engine.mode)
+    engine.running = False
+    engine.add_log(f"Mode → {engine.mode}  (springs preserved)")
+    return {"ok": True}
+
+
 @app.post("/config")
 async def config(data: dict):
-    engine.mode         = data.get('mode',         engine.mode)
+    new_ni = max(1, min(8,  int(data.get('n_inputs',  engine.n_inputs))))
+    new_nu = max(1, min(16, int(data.get('n_upper',   engine.n_upper))))
+    new_nl = max(1, min(16, int(data.get('n_lower',   engine.n_lower))))
+
+    topo_changed = (
+        new_ni != engine.n_inputs or
+        new_nu != engine.n_upper  or
+        new_nl != engine.n_lower
+    )
+
+    # Non-topology settings — always apply
     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}
+    engine.n_inputs     = new_ni
+    engine.n_upper      = new_nu
+    engine.n_lower      = new_nl
+
+    # Mode via /set_mode is preferred; config can also carry it
+    if 'mode' in data:
+        engine.mode = data['mode']
+
+    if topo_changed:
+        engine.running = False
+        engine._init_mesh()
+        engine.logs = []
+        engine.add_log(
+            f"Mesh rebuilt: D={new_ni} U{new_nu}·L{new_nl} | {engine.architecture}"
+        )
+    else:
+        engine.add_log(
+            f"Config: {engine.mode}|{engine.architecture}"
+            f"|D={new_ni}|α={engine.back_alpha:.2f}"
+        )
+
+    return {"ok": True, "topo_changed": topo_changed}
+
 
 @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))
+    if   layer == 'inputs': engine.n_inputs = max(1, min(8,  engine.n_inputs + delta))
+    elif layer == 'upper':  engine.n_upper  = max(1, min(16, engine.n_upper  + delta))
+    elif layer == 'lower':  engine.n_lower  = max(1, min(16, 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}
+    engine.add_log(
+        f"Topology → D={engine.n_inputs} U{engine.n_upper}·L{engine.n_lower}"
+    )
+    return {
+        "ok": True,
+        "n_inputs": engine.n_inputs,
+        "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("/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
+    def parse(v):
+        if v is None or v in ('', 'null'): return None
+        if isinstance(v, list):            return [float(x) for x in v]
+        s = str(v)
+        if ',' in s:
+            return [float(x.strip()) for x in s.split(',') if x.strip()]
+        try:    return float(s)
+        except: return None
+
+    a = parse(data.get('a')) or 5.0
+    b = parse(data.get('b')) or 3.0
+    c = parse(data.get('c'))
     if c is None and engine.mode == 'training':
-        c = engine.ground_truth(a, b)
+        c = engine.ground_truth(
+            engine._to_vec(a, engine.n_inputs),
+            engine._to_vec(b, engine.n_inputs),
+        )
     engine.batch_queue.clear()
     engine.set_problem(a, b, c)
     engine.running = True
-    engine.add_log(f"Custom: A={a} B={b} target={c}")
+    engine.add_log(f"Custom: A={a} B={b} C={c}")
     return {"ok": True}
 
+
 @app.post("/halt")
 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)