Update app.py

app.py

@@ -8,10 +8,10 @@ app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
 DIM = 8
-LR = 0.05
+LR = 0.02        # Slower, highly stable learning rate
 EWC_LAMBDA = 0.8
 FISHER_DECAY = 0.95
-DAMPING = 0.5
+DAMPING = 0.6    # Increased damping for visual stability
 DT = 0.2
 
 # --- AUTO DATA GENERATOR ---
@@ -78,13 +78,13 @@ class PristineMesh:
                 p1, p2 = self.nodes[n1]['pos'], self.nodes[n2]['pos']
                 if math.hypot(p1[0]-p2[0], p1[1]-p2[1]) < 1.05:
                     key = tuple(sorted([n1, n2]))
-                    self.springs[key] = random.uniform(0.4, 0.6)
+                    self.springs[key] = random.uniform(0.1, 0.4)
                     self.fisher[key] = 0.0
                     self.anchor_k[key] = self.springs[key]
                     
-        self.c_nodes = [n for n in self.nodes if self.nodes[n]['kind'] == 'C']
-        self.a_nodes = [n for n in self.nodes if self.nodes[n]['kind'] == 'A']
-        self.b_nodes = [n for n in self.nodes if self.nodes[n]['kind'] == 'B']
+        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):
         for i, nid in enumerate(self.a_nodes): self.nodes[nid]['x'] = a_vec[i]
@@ -94,7 +94,7 @@ class PristineMesh:
                 data['x'] = 0.0
                 data['vel'] = 0.0
 
-    def settle(self, steps=40):
+    def settle(self, steps=30):
         for _ in range(steps):
             forces = {n: 0.0 for n in self.nodes}
             for (u, v), K in self.springs.items():
@@ -104,9 +104,12 @@ class PristineMesh:
             
             for nid, data in self.nodes.items():
                 if not data['anchored']:
-                    f = forces[nid] - (0.05 * data['x'])
+                    f = forces[nid] - (0.05 * data['x']) # Weak grounding
                     data['vel'] = data['vel'] * DAMPING + f * DT
                     data['x'] += data['vel'] * DT
+                    
+                    # MAGICAL FIX: Bounding prevents mathematical explosion
+                    data['x'] = max(-2.0, min(2.0, data['x']))
 
     def get_predictions(self):
         return [self.nodes[n]['x'] for n in self.c_nodes]
@@ -116,25 +119,31 @@ class PristineMesh:
         for i, nid in enumerate(self.c_nodes):
             errors[nid] = self.nodes[nid]['x'] - target_vec[i]
             
-        for _ in range(3):
+        # Deep Error Diffusion
+        for _ in range(5):
             next_err = dict(errors)
             for (u, v), K in self.springs.items():
-                next_err[u] += K * errors[v] * 0.1
-                next_err[v] += K * errors[u] * 0.1
+                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 # Decay to prevent error explosion
             errors = next_err
 
         for key in self.springs:
             u, v = key
+            # True gradient formulation
             err_gradient = (errors[u] - errors[v]) * (self.nodes[u]['x'] - self.nodes[v]['x'])
             
             if mode == 'train':
-                self.springs[key] -= LR * err_gradient
+                # FIXED: MUST BE += TO MINIMIZE ERROR!
+                self.springs[key] += LR * err_gradient
                 self.fisher[key] = FISHER_DECAY * self.fisher[key] + (1 - FISHER_DECAY) * (err_gradient ** 2)
             elif mode == 'infer':
                 penalty = EWC_LAMBDA * self.fisher[key] * (self.springs[key] - self.anchor_k[key])
-                self.springs[key] -= (LR * 0.5 * err_gradient) + penalty
+                self.springs[key] += (LR * 0.5 * err_gradient) - penalty
                 
-            self.springs[key] = max(-4.0, min(8.0, self.springs[key]))
+            # Stable K bounds
+            self.springs[key] = max(-1.0, min(3.0, self.springs[key]))
 
     def save_anchors(self):
         self.anchor_k = dict(self.springs)
@@ -168,11 +177,14 @@ class Engine:
         self.current_type = sample['type']
         
         self.mesh.set_inputs(sample['a'], sample['b'])
-        self.mesh.settle(steps=30)
+        self.mesh.settle(steps=25)
         preds = self.mesh.get_predictions()
         
         if sample['type'] != 'manual':
+            # Clean Mean Absolute Error
             err = float(np.mean(np.abs(np.array(preds) - np.array(sample['c']))))
+            if math.isnan(err): err = 1.0 # Safety catch
+            
             self.current_err = err
             self.error_hist.append(err)
             if len(self.error_hist) > 100: self.error_hist.pop(0)
@@ -180,10 +192,9 @@ class Engine:
             if self.mode == 'infer':
                 self.test_results.append({'type': self.current_type, 'err': err})
 
-            # Apply LMS + EWC
+            # Apply correct LMS + EWC
             self.mesh.lms_update(sample['c'], mode=self.mode)
         else:
-            # For manual mode, just show prediction without training
             self.current_err = 0.0
         
         self.iter += 1
@@ -199,11 +210,16 @@ class Engine:
             errs = []
             for sample in self.train_data:
                 self.mesh.set_inputs(sample['a'], sample['b'])
-                self.mesh.settle(15)
+                self.mesh.settle(20)
                 self.mesh.lms_update(sample['c'], mode='train')
                 preds = self.mesh.get_predictions()
-                errs.append(np.mean(np.abs(np.array(preds) - np.array(sample['c']))))
-            self.add_log(f"Ep {ep+1} | Avg Err: {np.mean(errs):.4f}")
+                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}")
+            print(f"Epoch {ep+1} | Avg Err: {avg_e:.4f}")
+            
         self.mesh.save_anchors()
         self.add_log("✓ Training Complete. EWC Anchors saved.")
         self.mode = 'idle'
@@ -228,7 +244,7 @@ except Exception as e:
 def loop():
     while True:
         if engine.running: engine.run_step()
-        time.sleep(0.08) # Slowed down slightly so UI visualizes it nicely
+        time.sleep(0.06)
 threading.Thread(target=loop, daemon=True).start()
 
 @app.get("/", response_class=HTMLResponse)