Update app.py

app.py

@@ -67,7 +67,7 @@ class PristineMesh:
             for c in range(w):
                 nid = f"{kind}_r{r}_c{c}"
                 self.nodes[nid] = {
-                    'x': 0.0, 'vel': 0.0, 'kind': kind,
+                    'x': 0.0, 'vel': 0.0, 'kind': kind, 'row': r, 'col': c,
                     'pos': (x_offset + c, y), 'anchored': kind in ['A', 'B']
                 }
 
@@ -151,34 +151,49 @@ class Engine:
         self.test_data = []
         self.error_hist = []
         self.current_err = 0.0
+        self.current_type = '—'
+        self.test_results = []
 
     def add_log(self, msg):
         self.logs.insert(0, f"[{self.iter:05d}] {msg}")
-        if len(self.logs) > 30: self.logs.pop()
+        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=30)
         preds = self.mesh.get_predictions()
         
-        err = float(np.mean(np.abs(np.array(preds) - np.array(sample['c']))))
-        self.current_err = err
-        self.error_hist.append(err)
-        if len(self.error_hist) > 100: self.error_hist.pop(0)
+        if sample['type'] != 'manual':
+            err = float(np.mean(np.abs(np.array(preds) - np.array(sample['c']))))
+            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)
+            # Apply 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
-        if self.iter % 10 == 0:
-            self.add_log(f"[{sample['type']}] err: {err:.4f}")
+        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):
-        self.add_log("⚡ Offline Training Started...")
+        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 = []
@@ -188,9 +203,19 @@ class Engine:
                 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"Epoch {ep+1} | Avg Err: {np.mean(errs):.4f}")
+            self.add_log(f"Ep {ep+1} | Avg Err: {np.mean(errs):.4f}")
         self.mesh.save_anchors()
         self.add_log("✓ Training Complete. EWC Anchors saved.")
+        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:
@@ -203,7 +228,7 @@ except Exception as e:
 def loop():
     while True:
         if engine.running: engine.run_step()
-        time.sleep(0.05)
+        time.sleep(0.08) # Slowed down slightly so UI visualizes it nicely
 threading.Thread(target=loop, daemon=True).start()
 
 @app.get("/", response_class=HTMLResponse)
@@ -213,27 +238,50 @@ async def ui(): return FileResponse("index.html")
 async def state():
     return {
         'nodes': engine.mesh.nodes,
-        # FIXED: Serialize tuple keys safely for JSON by joining with a pipe '|'
         '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
+        'logs': engine.logs,
+        'current_type': engine.current_type,
+        'queue_size': len(engine.queue),
+        'type_acc': engine.get_accuracy_summary(),
+        'dim': DIM
     }
 
 @app.post("/train")
-async def train():
-    threading.Thread(target=engine.train_offline, args=(5,), daemon=True).start()
+async def train(data: dict):
+    ep = int(data.get('epochs', 5))
+    threading.Thread(target=engine.train_offline, args=(ep,), daemon=True).start()
     return {"ok": True}
 
 @app.post("/infer")
-async def infer():
+async def infer(data: dict):
+    n = int(data.get('n', 200))
     engine.mode = 'infer'
-    engine.queue.extend(engine.test_data)
+    engine.test_results = []
+    engine.queue.clear()
+    engine.queue.extend(engine.test_data[:n])
     engine.running = True
     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("/halt")
 async def halt(): engine.running = False; return {"ok": True}