Update app.py

app.py

@@ -6,157 +6,249 @@ from fastapi.middleware.cors import CORSMiddleware
 app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
-FWD_K       = 2.2
-DAMPING     = 0.55
-DT          = 0.12
-MICRO       = 6
-SETTLE      = 0.004
-CONV_THRESH = 0.02
-BRIDGE_K    = 0.20   # passive bridge spring constant — soft coupling, not learned
+FWD_K          = 2.2
+DAMPING        = 0.55
+DT             = 0.12
+MICRO          = 6
+SETTLE         = 0.004
+CONV_THRESH    = 0.02
+STIFF_EPS      = 0.0005
+STIFF_INTERVAL = 1.0
+
+
+# ── ATOMIC UNIT ───────────────────────────────────────────────────────────────
+
+class HourglassUnit:
+    def __init__(self, uid, n_upper, n_lower, architecture='additive'):
+        self.uid             = uid
+        self.n_upper         = n_upper
+        self.n_lower         = n_lower
+        self.architecture    = architecture
+        self.nodes           = {}
+        self.springs         = {}
+        self._prev_springs   = {}
+        self.stiffness_delta = 0.0
+        self.c_val           = 0.0
+        self.a_val           = 0.0
+        self.b_val           = 0.0
+        self._rebuild()
+
+    def _rebuild(self):
+        self.nodes   = {}
+        self.springs = {}
+        for j in range(1, self.n_upper + 1):
+            self.nodes[f'U{j}'] = {'x': 0.0, 'vel': 0.0}
+        for j in range(1, self.n_lower + 1):
+            self.nodes[f'L{j}'] = {'x': 0.0, 'vel': 0.0}
+        for j in range(1, self.n_upper + 1):
+            self.springs[('A', f'U{j}')] = round(random.uniform(0.85, 1.15), 4)
+            self.springs[(f'U{j}', 'C')] = round(random.uniform(0.85, 1.15), 4)
+        for j in range(1, self.n_lower + 1):
+            self.springs[('B', f'L{j}')] = round(random.uniform(0.85, 1.15), 4)
+            self.springs[(f'L{j}', 'C')] = round(random.uniform(0.85, 1.15), 4)
+
+    def reset_hidden(self):
+        for nd in self.nodes.values():
+            nd['x'] = 0.0; nd['vel'] = 0.0
+
+    def elastic_step(self, a_val, b_val, c_target, c_anchored, alpha):
+        self.a_val = a_val
+        self.b_val = b_val
+        for _ in range(MICRO):
+            forces = {nid: 0.0 for nid in self.nodes}
+            for j in range(1, self.n_upper + 1):
+                uid = f'U{j}'
+                ak  = self.springs[('A', uid)]
+                f   = FWD_K * (ak * a_val - self.nodes[uid]['x'])
+                if alpha > 0 and c_anchored:
+                    f += alpha * self.springs[(uid, 'C')] * (c_target - self.nodes[uid]['x'])
+                forces[uid] += f
+            for j in range(1, self.n_lower + 1):
+                lid = f'L{j}'
+                bk  = self.springs[('B', lid)]
+                f   = FWD_K * (bk * b_val - self.nodes[lid]['x'])
+                if alpha > 0 and c_anchored:
+                    f += alpha * self.springs[(lid, 'C')] * (c_target - self.nodes[lid]['x'])
+                forces[lid] += f
+            max_v = 0.0
+            for nid, fv in forces.items():
+                nd        = self.nodes[nid]
+                nd['vel'] = nd['vel'] * DAMPING + fv * DT
+                nd['x']  += nd['vel'] * DT
+                max_v     = max(max_v, abs(nd['vel']))
+            if max_v < SETTLE:
+                break
 
+    def feedforward(self, a_val, b_val):
+        ff = {}
+        for j in range(1, self.n_upper + 1):
+            uid = f'U{j}'; ff[uid] = self.springs[('A', uid)] * a_val
+        for j in range(1, self.n_lower + 1):
+            lid = f'L{j}'; ff[lid] = self.springs[('B', 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{(i % self.n_upper)+1}'; lid = f'L{(i % self.n_lower)+1}'
+                pred += self.springs[(uid,'C')] * ff[uid] * self.springs[(lid,'C')] * ff[lid]
+        else:
+            pred = (sum(self.springs[(f'U{j}','C')] * ff[f'U{j}'] for j in range(1, self.n_upper+1)) +
+                    sum(self.springs[(f'L{j}','C')] * ff[f'L{j}'] for j in range(1, self.n_lower+1)))
+        self.c_val = pred
+        return pred, ff
+
+    def lms_update(self, error, a_val, b_val, ff):
+        grads = {}
+        if self.architecture == 'additive':
+            for j in range(1, self.n_upper + 1):
+                uid = f'U{j}'
+                grads[('A', uid)] = self.springs[(uid,'C')] * a_val
+                grads[(uid, 'C')] = self.springs[('A',uid)] * a_val
+            for j in range(1, self.n_lower + 1):
+                lid = f'L{j}'
+                grads[('B', lid)] = self.springs[(lid,'C')] * b_val
+                grads[(lid, 'C')] = self.springs[('B',lid)] * b_val
+        else:
+            nm = max(self.n_upper, self.n_lower)
+            for i in range(nm):
+                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')]
+                Uv  = ff[uid]; Lv = ff[lid]
+                grads[('A',uid)] = grads.get(('A',uid),0.0) + ku*a_val*kl*Lv
+                grads[('B',lid)] = grads.get(('B',lid),0.0) + kl*b_val*ku*Uv
+                grads[(uid,'C')] = grads.get((uid,'C'), 0.0) + Uv*kl*Lv
+                grads[(lid,'C')] = grads.get((lid,'C'), 0.0) + 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():
+            if key in self.springs:
+                self.springs[key] -= mu * g
+                self.springs[key]  = max(-30.0, min(30.0, self.springs[key]))
+
+    def sensitivity_to_a(self):
+        if self.architecture == 'additive':
+            return sum(self.springs[('A',f'U{j}')] * self.springs[(f'U{j}','C')]
+                       for j in range(1, self.n_upper+1))
+        return 1.0
+
+    def sensitivity_to_b(self):
+        if self.architecture == 'additive':
+            return sum(self.springs[('B',f'L{j}')] * self.springs[(f'L{j}','C')]
+                       for j in range(1, self.n_lower+1))
+        return 1.0
+
+    def take_stiffness_snapshot(self):
+        if not self._prev_springs:
+            self._prev_springs = dict(self.springs); return 0.0
+        changed = sum(1 for k in self.springs
+                      if abs(self.springs[k] - self._prev_springs.get(k, self.springs[k])) > STIFF_EPS)
+        self._prev_springs   = dict(self.springs)
+        self.stiffness_delta = (changed / len(self.springs) * 100.0) if self.springs else 0.0
+        return self.stiffness_delta
+
+    def to_dict(self):
+        return {
+            'springs': {f"{u}→{v}": round(k, 5) for (u,v),k in self.springs.items()},
+            'nodes':   {nid: {'x': round(nd['x'],5), 'vel': round(nd['vel'],5)}
+                        for nid, nd in self.nodes.items()},
+            'c_val':           round(self.c_val,   4),
+            'a_val':           round(self.a_val,   4),
+            'b_val':           round(self.b_val,   4),
+            'stiffness_delta': round(self.stiffness_delta, 1),
+            'n_upper':         self.n_upper,
+            'n_lower':         self.n_lower,
+        }
+
+
+# ── ENGINE ────────────────────────────────────────────────────────────────────
 
 class SimEngine:
+    CREDIT_MODES = ['elastic_backprop', 'greedy', 'param_hg', 'independent']
+
     def __init__(self):
-        self.mode          = 'training'
-        self.architecture  = 'additive'
-        self.dataset_type  = 'housing'
-        self.n_inputs      = 1
-        self.n_upper       = 3
-        self.n_lower       = 3
-        self.back_alpha    = 0.45
-        self.cross_connect = False
-        self.running       = False
-        self.batch_queue   = collections.deque()
-        self.logs          = []
-        self.iteration     = 0
-        self.current_error      = 0.0
+        self.mode             = 'training'
+        self.architecture     = 'additive'
+        self.dataset_type     = 'housing'
+        self.n_inputs         = 1
+        self.n_upper          = 3
+        self.n_lower          = 3
+        self.back_alpha       = 0.45
+        self.stack_levels     = 0
+        self.credit_mode      = 'elastic_backprop'
+        self.reverse_mode     = False
+        self.individual_train = False
+        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.bridge_springs     = {}
-        self._init_mesh()
+        self.history          = []
+        self.units            = {}
+        self.topology         = []
+        self.connections      = []
+        self._a_vec           = [2.0]
+        self._b_vec           = [3.0]
+        self._c_vec           = []
+        self._last_stiff_time = time.time()
+        self.stiffness_active = 0.0
+        self.stiffness_history = []
+        self._init_stack()
 
     # ── TOPOLOGY ──────────────────────────────────────────────────────────────
 
-    def _build_layers(self):
-        n, nu, nl = self.n_inputs, self.n_upper, self.n_lower
-        return [
-            [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):
-        self.iteration          = 0
-        self.current_error      = 0.0
+    def _init_stack(self):
+        self.iteration   = 0
+        self.current_error = 0.0
         self.current_prediction = 0.0
-        self.history            = []
-        self.bridge_springs     = {}
-        self.layers             = self._build_layers()
-        n = self.n_inputs
-
-        self.nodes = {}
-        for layer in self.layers:
-            for nid in layer:
-                anchored = nid[0] in ('A', 'B')
-                self.nodes[nid] = {'x': 0.0, 'vel': 0.0, 'anchored': anchored}
-        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 = {}
-        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)
-
-        if self.cross_connect:
-            self._add_bridge_nodes()
-
-    # ── BRIDGE NODES ──────────────────────────────────────────────────────────
-
-    def _add_bridge_nodes(self):
-        """
-        For each adjacent dimension pair (d, d+1), insert two passive bridge
-        vertices:
-          XU{d}  — sits between U{d}_{n_upper} and U{d+1}_1 (upper hidden layer)
-          XL{d}  — sits between L{d}_{n_lower} and L{d+1}_1 (lower hidden layer)
-
-        Bridge springs are FIXED at BRIDGE_K and never touched by LMS.
-        Each bridge node settles to a position driven by its two neighbours,
-        and in turn exerts a soft reaction pull on those neighbours — creating
-        a passive physical information channel between dimensions without
-        interfering with per-dimension gradient descent.
-        """
-        n = self.n_inputs
-        if n < 2:
+        self.history     = []
+        self.units       = {}
+        self.topology    = []
+        self.connections = []
+
+        n    = max(1, self.n_inputs)
+        nu   = self.n_upper
+        nl   = self.n_lower
+        arch = self.architecture
+
+        if self.reverse_mode:
+            uid = 'HG_REV'
+            self.units[uid] = HourglassUnit(uid, nu, nl, arch)
+            self.topology   = [[uid]]
             return
-        for d in range(1, n):
-            xuid = f'XU{d}'
-            self.nodes[xuid] = {'x': 0.0, 'vel': 0.0, 'anchored': False}
-            self.bridge_springs[(xuid, f'U{d}_{self.n_upper}')] = BRIDGE_K
-            self.bridge_springs[(xuid, f'U{d+1}_1')]            = BRIDGE_K
-
-            xlid = f'XL{d}'
-            self.nodes[xlid] = {'x': 0.0, 'vel': 0.0, 'anchored': False}
-            self.bridge_springs[(xlid, f'L{d}_{self.n_lower}')] = BRIDGE_K
-            self.bridge_springs[(xlid, f'L{d+1}_1')]            = BRIDGE_K
-
-    # ── CROSS CONNECT TOGGLE ──────────────────────────────────────────────────
-
-    def toggle_cross_connect(self):
-        self.cross_connect = not self.cross_connect
-        self.running = False
-        self._init_mesh()
-        self.logs = []
-        nb = len(self.bridge_springs) // 2  # each bridge has 2 springs
-        if self.cross_connect:
-            self.add_log(
-                f"Cross-connect ON — {nb} passive bridge "
-                f"{'vertex' if nb == 1 else 'vertices'} "
-                f"(k={BRIDGE_K}, not learned)"
-            )
-        else:
-            self.add_log("Cross-connect OFF — independent parallel hourglasses")
-
-    # ── LOGGING ───────────────────────────────────────────────────────────────
-
-    def reset(self):
-        self.running = False
-        self.batch_queue.clear()
-        self.logs = []
-        self._init_mesh()
 
-    def add_log(self, msg):
-        self.logs.insert(0, f"[{self.iteration:05d}] {msg}")
-        if len(self.logs) > 50:
-            self.logs.pop()
+        leaves = []
+        for i in range(n):
+            uid = f'HG_L0_{i}'
+            self.units[uid] = HourglassUnit(uid, nu, nl, arch)
+            leaves.append(uid)
+        self.topology.append(leaves)
+
+        for lv in range(1, self.stack_levels + 1):
+            prev = self.topology[-1]; curr = []
+            for pi in range(0, len(prev), 2):
+                ua  = prev[pi]
+                ub  = prev[pi+1] if pi+1 < len(prev) else prev[pi]
+                uid = f'HG_L{lv}_{pi//2}'
+                self.units[uid] = HourglassUnit(uid, nu, nl, arch)
+                curr.append(uid)
+                self.connections.append({'from_uid': ua, 'to_uid': uid, 'to_port': 'A'})
+                self.connections.append({'from_uid': ub, 'to_uid': uid, 'to_port': 'B'})
+            self.topology.append(curr)
 
-    # ── HELPERS ───────────────────────────────────────────────────────────────
+    # ── DATASET ───────────────────────────────────────────────────────────────
 
     def _to_vec(self, val, n):
         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 (v[:n] if len(v) >= n else v + [v[-1]] * (n - len(v)))
         return [float(val)] * n
 
-    # ── DATASET ───────────────────────────────────────────────────────────────
-
     def ground_truth(self, a_vec, b_vec):
-        n     = self.n_inputs
-        a_vec = self._to_vec(a_vec, n)
-        b_vec = self._to_vec(b_vec, n)
-        t     = self.dataset_type
         result = []
-        for i in range(n):
-            a, b = a_vec[i], b_vec[i]
+        for a, b in zip(a_vec, b_vec):
+            t = self.dataset_type
             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))
@@ -167,225 +259,213 @@ class SimEngine:
     # ── PROBLEM SETUP ─────────────────────────────────────────────────────────
 
     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 all hidden + bridge nodes
-        for nid, nd in self.nodes.items():
-            if nid[0] in ('U', 'L', 'X'):
-                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 STEP ──────────────────────────────────────────────────────────
-
-    def _elastic_step(self, n_steps):
-        alpha = self.back_alpha
-        n     = self.n_inputs
-
-        for _ in range(n_steps):
-            forces = {nid: 0.0 for nid, nd in self.nodes.items()
-                      if not nd['anchored']}
-
-            # Standard hourglass forces (unchanged — no merge resolution needed)
-            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}'
-                    ak  = self.springs[(f'A{d}', uid)]
-                    f   = FWD_K * (ak * A_val - self.nodes[uid]['x'])
-                    if alpha > 0:
-                        kuc = self.springs[(uid, f'C{d}')]
-                        f  += alpha * kuc * (C_val - self.nodes[uid]['x'])
-                    forces[uid] += f
-
-                for j in range(1, self.n_lower+1):
-                    lid = f'L{d}_{j}'
-                    bk  = self.springs[(f'B{d}', lid)]
-                    f   = FWD_K * (bk * B_val - self.nodes[lid]['x'])
-                    if alpha > 0:
-                        klc = self.springs[(lid, f'C{d}')]
-                        f  += alpha * klc * (C_val - self.nodes[lid]['x'])
-                    forces[lid] += f
-
-                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))
-                    )
-                    forces[f'C{d}'] = forces.get(f'C{d}', 0.0) + \
-                                      FWD_K * (rest_c - c['x'])
-
-            # Bridge forces — symmetric Hooke's law, passive (not learned)
-            # Bridge node pulled toward both neighbours; each neighbour gets
-            # an equal-and-opposite soft reaction pull toward the bridge.
-            for (bnode, peer), k in self.bridge_springs.items():
-                xb       = self.nodes[bnode]['x']
-                xp       = self.nodes[peer]['x']
-                spring_f = FWD_K * k * (xp - xb)
-                if bnode in forces: forces[bnode] += spring_f
-                if peer  in forces: forces[peer]  -= spring_f  # weak reaction
+        n = max(1, self.n_inputs)
+        self._a_vec = self._to_vec(a, n)
+        self._b_vec = self._to_vec(b, n)
+        self._c_vec = list(self._to_vec(c_target, n)) if c_target is not None else []
 
-            max_v = 0.0
-            for nid, f in forces.items():
-                nd        = self.nodes[nid]
-                nd['vel'] = nd['vel'] * DAMPING + f * DT
-                nd['x']  += nd['vel'] * DT
-                max_v     = max(max_v, abs(nd['vel']))
-            if max_v < SETTLE:
-                break
+    # ── LOGGING ───────────────────────────────────────────────────────────────
 
-    # ── FEEDFORWARD ───────────────────────────────────────────────────────────
-
-    def _feedforward(self):
-        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}'
-                # With cross_connect the node's settled position already
-                # encodes the soft bridge influence — use it directly.
-                ff[uid] = (self.nodes[uid]['x'] if self.cross_connect
-                           else 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.nodes[lid]['x'] if self.cross_connect
-                           else 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 ────────────────────────────────────────────────────────────
-    # Bridge springs are never in self.springs so they are never touched here.
-    # Each dimension's LMS update is fully independent — no cross-gradient
-    # bleed, no error inflation.
-
-    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}'
-                    ak_key  = (f'A{d}', uid)
-                    uc_key  = (uid, f'C{d}')
-                    grads[ak_key] = self.springs[uc_key] * A_val
-                    grads[uc_key] = self.springs[ak_key] * A_val
-                for j in range(1, self.n_lower+1):
-                    lid     = f'L{d}_{j}'
-                    bk_key  = (f'B{d}', lid)
-                    lc_key  = (lid, f'C{d}')
-                    grads[bk_key] = self.springs[lc_key] * B_val
-                    grads[lc_key] = self.springs[bk_key] * B_val
+    def add_log(self, msg):
+        self.logs.insert(0, f"[{self.iteration:05d}] {msg}")
+        if len(self.logs) > 50: self.logs.pop()
+
+    def reset(self):
+        self.running = False; self.batch_queue.clear()
+        self.logs = []; self._init_stack()
+
+    # ── FORWARD PASS ──────────────────────────────────────────────────────────
+
+    def _forward_pass(self, training):
+        a_vec = self._a_vec; b_vec = self._b_vec; c_vec = self._c_vec
+        alpha = self.back_alpha; io = {}
+        only_level = (len(self.topology) == 1)
+
+        for i, uid in enumerate(self.topology[0]):
+            av = a_vec[i] if i < len(a_vec) else a_vec[-1]
+            bv = b_vec[i] if i < len(b_vec) else b_vec[-1]
+            u  = self.units[uid]; u.reset_hidden()
+            anchor = training and bool(c_vec) and (only_level or self.individual_train)
+            if anchor:
+                if self.individual_train and not only_level:
+                    c_tgt = self.ground_truth([av], [bv])[0]
+                else:
+                    c_tgt = c_vec[i] if i < len(c_vec) else c_vec[-1]
             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():
-                if key in self.springs:
-                    self.springs[key] -= mu * g
-                    self.springs[key]  = max(-30.0, min(30.0, self.springs[key]))
+                c_tgt = 0.0
+            u.elastic_step(av, bv, c_tgt, anchor, alpha)
+            pred, ff = u.feedforward(av, bv)
+            io[uid] = (av, bv, pred, ff)
+
+        for lv in range(1, len(self.topology)):
+            for uid in self.topology[lv]:
+                conns = [c for c in self.connections if c['to_uid'] == uid]
+                a_src = next((c['from_uid'] for c in conns if c['to_port'] == 'A'), None)
+                b_src = next((c['from_uid'] for c in conns if c['to_port'] == 'B'), None)
+                av    = io[a_src][2] if a_src in io else 0.0
+                bv    = io[b_src][2] if b_src in io else 0.0
+                u     = self.units[uid]; u.reset_hidden()
+                is_root = (lv == len(self.topology) - 1)
+                anchor  = training and bool(c_vec) and is_root
+                c_tgt   = c_vec[0] if anchor else 0.0
+                u.elastic_step(av, bv, c_tgt, anchor, alpha)
+                pred, ff = u.feedforward(av, bv)
+                io[uid] = (av, bv, pred, ff)
+
+        return io[self.topology[-1][-1]][2], io
+
+    def _forward_reverse(self, training):
+        uid  = self.topology[0][0]; u = self.units[uid]
+        c_in = self._c_vec[0] if self._c_vec else 0.0
+        a_gt = self._a_vec[0] if self._a_vec else 0.0
+        u.reset_hidden()
+        u.elastic_step(c_in, c_in, a_gt if training else 0.0, training, self.back_alpha)
+        pred, ff = u.feedforward(c_in, c_in)
+        if training:
+            u.lms_update(pred - a_gt, c_in, c_in, ff)
+        return pred, {uid: (c_in, c_in, pred, ff)}
+
+    # ── CREDIT ASSIGNMENT ─────────────────────────────────────────────────────
+
+    def _backprop(self, root_err, io):
+        errors = {self.topology[-1][-1]: root_err}
+        for lv in range(len(self.topology)-1, -1, -1):
+            for uid in self.topology[lv]:
+                if uid not in errors: continue
+                err = errors[uid]; av, bv, _, ff = io[uid]
+                self.units[uid].lms_update(err, av, bv, ff)
+                if lv > 0:
+                    u     = self.units[uid]
+                    conns = [c for c in self.connections if c['to_uid'] == uid]
+                    a_src = next((c['from_uid'] for c in conns if c['to_port'] == 'A'), None)
+                    b_src = next((c['from_uid'] for c in conns if c['to_port'] == 'B'), None)
+                    if a_src:
+                        errors[a_src] = errors.get(a_src, 0.0) + err * u.sensitivity_to_a()
+                    if b_src and b_src != a_src:
+                        errors[b_src] = errors.get(b_src, 0.0) + err * u.sensitivity_to_b()
+
+    def _greedy(self, root_err, io):
+        n = len(self.topology)
+        for lv in range(n-1, -1, -1):
+            scale = 1.0 / max(1, n - lv)
+            for uid in self.topology[lv]:
+                av, bv, _, ff = io[uid]
+                self.units[uid].lms_update(root_err * scale, av, bv, ff)
+
+    def _param_hg(self, root_err, io):
+        for level in self.topology:
+            for uid in level:
+                av, bv, _, ff = io[uid]
+                self.units[uid].lms_update(root_err, av, bv, ff)
+
+    def _independent(self, root_err, io):
+        errors = {self.topology[-1][-1]: root_err}
+        for lv in range(len(self.topology)-1, 0, -1):
+            for uid in self.topology[lv]:
+                if uid not in errors: continue
+                err = errors[uid]; av, bv, _, ff = io[uid]
+                self.units[uid].lms_update(err, av, bv, ff)
+                u     = self.units[uid]
+                conns = [c for c in self.connections if c['to_uid'] == uid]
+                a_src = next((c['from_uid'] for c in conns if c['to_port'] == 'A'), None)
+                b_src = next((c['from_uid'] for c in conns if c['to_port'] == 'B'), None)
+                if a_src:
+                    errors[a_src] = errors.get(a_src, 0.0) + err * u.sensitivity_to_a()
+                if b_src and b_src != a_src:
+                    errors[b_src] = errors.get(b_src, 0.0) + err * u.sensitivity_to_b()
+        # Leaves: independent GT
+        for i, uid in enumerate(self.topology[0]):
+            av, bv, c_pred, ff = io[uid]
+            gt_i = self.ground_truth([av], [bv])[0]
+            self.units[uid].lms_update(c_pred - gt_i, av, bv, ff)
+
+    def _train(self, root_err, io):
+        m = self.credit_mode
+        if   m == 'elastic_backprop': self._backprop(root_err, io)
+        elif m == 'greedy':           self._greedy(root_err, io)
+        elif m == 'param_hg':         self._param_hg(root_err, io)
+        elif m == 'independent':      self._independent(root_err, io)
+
+    # ── STIFFNESS MONITOR ─────────────────────────────────────────────────────
+
+    def _update_stiffness(self):
+        now = time.time()
+        if now - self._last_stiff_time < STIFF_INTERVAL:
+            return
+        self._last_stiff_time = now
+        deltas = [u.take_stiffness_snapshot() for u in self.units.values()]
+        self.stiffness_active = round(sum(deltas) / len(deltas), 1) if deltas else 0.0
+        self.stiffness_history.append(self.stiffness_active)
+        if len(self.stiffness_history) > 60:
+            self.stiffness_history.pop(0)
 
     # ── PHYSICS STEP ──────────────────────────────────────────────────────────
 
     def physics_step(self):
-        self._elastic_step(MICRO)
-        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)
+        training = (self.mode == 'training')
+
+        # Reverse mode: C→A reconstruction
+        if self.reverse_mode:
+            pred, io = self._forward_reverse(training)
+            a_gt     = self._a_vec[0] if self._a_vec else 0.0
+            self.current_error      = round(abs(pred - a_gt), 5)
+            self.current_prediction = round(pred, 5)
+            self.iteration += 1
+            self.history.append(self.current_error)
+            if len(self.history) > 200: self.history.pop(0)
+            self._update_stiffness()
+            if self.current_error < CONV_THRESH:
+                self.add_log(f"✓ REV C={self._c_vec[0]:.2f} → A_pred={pred:.4f} gt={a_gt:.4f}")
+                return self._next_or_stop()
+            return True
 
-        self.current_prediction = round(sum(preds) / n, 5)
-        self.current_error      = round(sum(abs(e) for e in errors) / n, 5)
+        # Normal forward/stacked pass
+        pred, io = self._forward_pass(training)
+
+        # Flat multi-unit: average error across all leaf outputs vs their own GT
+        if len(self.topology) == 1 and len(self.topology[0]) > 1:
+            errors = []
+            for i, uid in enumerate(self.topology[0]):
+                av, bv, c_pred, _ = io[uid]
+                gt_i = (self._c_vec[i] if i < len(self._c_vec) else
+                        self.ground_truth([av], [bv])[0])
+                errors.append(c_pred - gt_i)
+            mean_err = sum(abs(e) for e in errors) / len(errors)
+            self.current_error      = round(mean_err, 5)
+            self.current_prediction = round(sum(io[uid][2]
+                                                for uid in self.topology[0]) / len(self.topology[0]), 5)
+            self.history.append(self.current_error)
+            if len(self.history) > 200: self.history.pop(0)
+            self._update_stiffness()
+            if self.current_error < CONV_THRESH:
+                self.add_log(f"✓ FLAT D={len(self.topology[0])} avg_err={mean_err:.4f}")
+                return self._next_or_stop()
+            if training:
+                for i, uid in enumerate(self.topology[0]):
+                    av, bv, _, ff = io[uid]
+                    self.units[uid].lms_update(errors[i], av, bv, ff)
+            self.iteration += 1
+            return True
+
+        # Stacked: single root output vs single GT
+        c_gt     = self._c_vec[0] if self._c_vec else None
+        root_err = (pred - c_gt) if c_gt is not None else 0.0
+        self.current_error      = round(abs(root_err), 5)
+        self.current_prediction = round(pred, 5)
         self.history.append(self.current_error)
-        if len(self.history) > 200:
-            self.history.pop(0)
+        if len(self.history) > 200: self.history.pop(0)
+        self._update_stiffness()
 
         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}")
+            n_units = len(self.units)
+            self.add_log(
+                f"✓ STACK L{self.stack_levels} [{n_units}u] "
+                f"P={pred:.4f} GT={c_gt:.4f} Δ={abs(root_err):.4f}"
+            )
             return self._next_or_stop()
 
-        if self.mode == 'training' and any(
-            self.nodes[f'C{d}']['anchored'] for d in range(1, n+1)
-        ):
-            self._lms_update(errors, ff)
+        if training and c_gt is not None:
+            self._train(root_err, io)
 
         self.iteration += 1
         return True
@@ -402,32 +482,41 @@ class SimEngine:
 
     def generate_batch(self, count=30):
         self.batch_queue.clear()
-        n  = self.n_inputs
-        nb = len(self.bridge_springs) // 2
+        n = max(1, self.n_inputs)
         for _ in range(count):
             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)
+            if self.reverse_mode:
+                c_vec = self.ground_truth(a_vec, b_vec)
+            else:
+                if self.stack_levels == 0:
+                    c_vec = self.ground_truth(a_vec, b_vec)
+                else:
+                    # Stacked: single output GT is the function of the first pair
+                    c_vec = [self.ground_truth([a_vec[0]], [b_vec[0]])[0]]
             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
-        tag = f'B{nb}' if self.cross_connect and nb else '·'
+        tag = f'L{self.stack_levels}' if self.stack_levels else 'flat'
         self.add_log(
             f"▶ {count} | {self.dataset_type} | "
-            f"D={n} U{self.n_upper}·L{self.n_lower} [{tag}]"
+            f"D={n} U{self.n_upper}·L{self.n_lower} "
+            f"[{tag}|{self.credit_mode[:4]}]"
         )
 
 
 # ── SERVER ────────────────────────────────────────────────────────────────────
 engine = SimEngine()
 
+
 def run_loop():
     while True:
         if engine.running:
             engine.physics_step()
         time.sleep(0.028)
 
+
 threading.Thread(target=run_loop, daemon=True).start()
 
 
@@ -438,33 +527,42 @@ async def get_ui():
 
 @app.get("/state")
 async def get_state():
-    springs_out = {f"{u}→{v}": round(k, 5) for (u, v), k in engine.springs.items()}
-    bridge_out  = {f"{u}→{v}": round(k, 5) for (u, v), k in engine.bridge_springs.items()}
-    n  = engine.n_inputs
-    nb = len(engine.bridge_springs) // 2
+    units_out = {uid: u.to_dict() for uid, u in engine.units.items()}
+    # Flatten all springs for display (prefixed with unit id)
+    all_springs = {}
+    for uid, u in engine.units.items():
+        short = uid.replace('HG_', '')
+        for (a, b), k in u.springs.items():
+            all_springs[f"{short}:{a}→{b}"] = round(k, 5)
+
     return {
-        'nodes':          engine.nodes,
-        'springs':        springs_out,
-        'bridge_springs': bridge_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:],
-        'running':        engine.running,
-        '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,
-        'cross_connect':  engine.cross_connect,
-        'n_bridges':      nb,
-        'bridge_k':       BRIDGE_K,
-        'queue_size':     len(engine.batch_queue),
+        'units':             units_out,
+        'topology':          engine.topology,
+        'connections':       engine.connections,
+        'springs':           all_springs,
+        '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_inputs':          engine.n_inputs,
+        'n_upper':           engine.n_upper,
+        'n_lower':           engine.n_lower,
+        'back_alpha':        engine.back_alpha,
+        'stack_levels':      engine.stack_levels,
+        'credit_mode':       engine.credit_mode,
+        'reverse_mode':      engine.reverse_mode,
+        'individual_train':  engine.individual_train,
+        'queue_size':        len(engine.batch_queue),
+        'stiffness_active':  engine.stiffness_active,
+        'stiffness_history': engine.stiffness_history,
+        'a_vec':             engine._a_vec,
+        'b_vec':             engine._b_vec,
+        'c_vec':             engine._c_vec,
     }
 
 
@@ -476,76 +574,69 @@ async def set_mode(data: dict):
     return {"ok": True}
 
 
-@app.post("/toggle_cross")
-async def toggle_cross():
-    engine.toggle_cross_connect()
-    return {
-        "ok":            True,
-        "cross_connect": engine.cross_connect,
-        "n_springs":     len(engine.springs),
-        "n_bridges":     len(engine.bridge_springs) // 2,
-        "bridge_k":      BRIDGE_K,
-    }
-
-
 @app.post("/config")
 async def config(data: dict):
-    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
-    )
-
-    engine.architecture = data.get('architecture', engine.architecture)
-    engine.dataset_type = data.get('dataset',      engine.dataset_type)
-    engine.back_alpha   = max(0.0, min(1.0, float(data.get('back_alpha', engine.back_alpha))))
-    engine.n_inputs     = new_ni
-    engine.n_upper      = new_nu
-    engine.n_lower      = new_nl
+    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))))
+    new_sl = max(0, min(4,  int(data.get('stack_levels',  engine.stack_levels))))
+
+    topo_changed = (new_ni != engine.n_inputs or new_nu != engine.n_upper or
+                    new_nl != engine.n_lower  or new_sl != engine.stack_levels)
+
+    engine.architecture    = data.get('architecture',     engine.architecture)
+    engine.dataset_type    = data.get('dataset',          engine.dataset_type)
+    engine.back_alpha      = max(0.0, min(1.0, float(data.get('back_alpha', engine.back_alpha))))
+    engine.credit_mode     = data.get('credit_mode',      engine.credit_mode)
+    engine.reverse_mode    = bool(data.get('reverse_mode', engine.reverse_mode))
+    engine.individual_train= bool(data.get('individual_train', engine.individual_train))
+    engine.n_inputs        = new_ni
+    engine.n_upper         = new_nu
+    engine.n_lower         = new_nl
+    engine.stack_levels    = new_sl
     if 'mode' in data:
-        engine.mode = data['mode']
+        engine.mode        = data['mode']
 
     if topo_changed:
         engine.running = False
-        engine._init_mesh()
+        engine._init_stack()
         engine.logs = []
-        nb = len(engine.bridge_springs) // 2
+        n_units = len(engine.units)
         engine.add_log(
-            f"Mesh rebuilt: D={new_ni} U{new_nu}·L{new_nl} "
-            f"cross={'ON ('+str(nb)+' bridges)' if engine.cross_connect else 'OFF'}"
+            f"Stack rebuilt: D={new_ni} U{new_nu}·L{new_nl} "
+            f"levels={new_sl} units={n_units} "
+            f"credit={engine.credit_mode}"
         )
     else:
         engine.add_log(
             f"Config: {engine.mode}|{engine.architecture}"
-            f"|D={new_ni}|α={engine.back_alpha:.2f}"
+            f"|α={engine.back_alpha:.2f}|{engine.credit_mode}"
         )
 
-    return {"ok": True, "topo_changed": topo_changed}
+    return {"ok": True, "topo_changed": topo_changed, "n_units": len(engine.units)}
 
 
 @app.post("/set_layer")
 async def set_layer(data: dict):
     layer = data.get('layer', '')
     delta = int(data.get('delta', 0))
-    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))
+    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))
+    elif layer == 'stack':  engine.stack_levels   = max(0, min(4,  engine.stack_levels   + delta))
     engine.running = False
-    engine._init_mesh()
-    nb = len(engine.bridge_springs) // 2
+    engine._init_stack()
     engine.add_log(
         f"Topology → D={engine.n_inputs} U{engine.n_upper}·L{engine.n_lower} "
-        f"cross={'ON ('+str(nb)+' bridges)' if engine.cross_connect else 'OFF'}"
+        f"stack={engine.stack_levels} units={len(engine.units)}"
     )
     return {
-        "ok":       True,
-        "n_inputs": engine.n_inputs,
-        "n_upper":  engine.n_upper,
-        "n_lower":  engine.n_lower,
+        "ok":           True,
+        "n_inputs":     engine.n_inputs,
+        "n_upper":      engine.n_upper,
+        "n_lower":      engine.n_lower,
+        "stack_levels": engine.stack_levels,
+        "n_units":      len(engine.units),
     }