Update app.py

app.py

@@ -9,40 +9,27 @@ from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 
 app = FastAPI()
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
 class SimEngine:
     def __init__(self):
         self.nodes = {}       
-        self.cells = []       
-        self.buffer = collections.deque()
         self.running = False
         self.mode = 'inference'       
-        self.distribution = 'uniform' 
-        self.problem_type = 'add'     
-        self.asymmetric = False       
+        self.problem_type = 'mult'     
         self.batch_queue = collections.deque()
         self.logs = []
         self.iteration = 0
-        self.current_target = None
         self.current_error = 0.0
         self.reset()
 
     def reset(self):
-        # Initializing within a visible range (0-10)
+        # A & B are the "Inputs", C is the "Model Output"
         self.nodes = {
-            'A': {'x': random.uniform(0, 5), 'y': 1.0, 'z': 0.0, 'anchored': False, 'k': 1.0, 'force': 0.0},
-            'B': {'x': random.uniform(0, 5), 'y': -1.0, 'z': 0.0, 'anchored': False, 'k': 0.8, 'force': 0.0}, 
-            'C': {'x': 10.0, 'y': 0.0, 'z': 0.0, 'anchored': True,  'k': 1.0, 'force': 0.0}  
+            'A': {'x': 2.0, 'anchored': True, 'k': 1.0, 'f': 0.0},
+            'B': {'x': 3.0, 'anchored': True, 'k': 1.0, 'f': 0.0}, 
+            'C': {'x': 6.0, 'anchored': False, 'k': 1.0, 'f': 0.0}  
         }
-        self.cells = [{'id': 'Cell_1', 'a': 'A', 'b': 'B', 'c': 'C'}]
-        self.buffer.clear()
         self.batch_queue.clear()
         self.logs = []
         self.iteration = 0
@@ -50,73 +37,58 @@ class SimEngine:
 
     def add_log(self, msg):
         self.logs.insert(0, f"[{self.iteration}]: {msg}")
-        if len(self.logs) > 30: self.logs.pop()
-
-    def set_problem(self, target_value):
-        self.current_target = target_value
-        self.nodes['C']['x'] = float(target_value)
-        # Randomize A and B slightly to prevent getting stuck in a local zero
-        self.nodes['A']['x'] = random.uniform(0, target_value/2)
-        self.nodes['B']['x'] = random.uniform(0, target_value/2)
-        self.add_log(f"New Target Load: {target_value}")
-        self.trigger_cells()
-
-    def trigger_cells(self):
-        for cell in self.cells:
-            na, nb, nc = self.nodes[cell['a']], self.nodes[cell['b']], self.nodes[cell['c']]
-            valA, valB, valC = na['x'], nb['x'], nc['x']
-            
-            # Logic calculation
-            pred = (valA + valB) if self.problem_type == 'add' else (valA * valB)
-            self.current_error = pred - valC 
-            
-            # If error is high, generate tension (Forces)
-            if abs(self.current_error) > 0.01: 
-                # Calculating the specific force for this step
-                force_mag = -self.current_error * 0.05
-                self.nodes['A']['force'] = force_mag
-                self.nodes['B']['force'] = force_mag
-                self.buffer.append({'target': cell['a'], 'f': force_mag})
-                self.buffer.append({'target': cell['b'], 'f': force_mag})
-            else:
-                self.nodes['A']['force'] = 0
-                self.nodes['B']['force'] = 0
+        if len(self.logs) > 20: self.logs.pop()
 
-    def physics_step(self):
-        if not self.buffer:
-            if self.current_target is not None and self.running and abs(self.current_error) < 0.05:
-                 self.add_log(f"SUCCESS: C={self.current_target} Solved.")
-                 self.current_target = None
-                 if self.batch_queue:
-                     time.sleep(0.5)
-                     self.set_problem(self.batch_queue.popleft())
-                 else:
-                     self.running = False
-            return False 
+    def set_problem(self, a, b, c_target=None):
+        self.nodes['A']['x'] = float(a)
+        self.nodes['B']['x'] = float(b)
         
-        event = self.buffer.popleft()
-        t_node = self.nodes[event['target']]
+        if self.mode == 'training':
+            # In Training, everything is locked to learn the K-factor
+            self.nodes['C']['x'] = float(c_target)
+            self.nodes['C']['anchored'] = True
+            self.add_log(f"TRAIN: {a} * {b} = {c_target}")
+        else:
+            # In Inference, C is free to drift to the predicted answer
+            self.nodes['C']['anchored'] = False
+            # Start C at a random point to see it "find" the answer
+            self.nodes['C']['x'] = random.uniform(-10, 10)
+            self.add_log(f"INFER: {a} * {b} = ?")
 
-        if t_node['anchored'] and self.mode != 'training': return True 
+    def physics_step(self):
+        na, nb, nc = self.nodes['A'], self.nodes['B'], self.nodes['C']
         
-        # Dampening to prevent the explosion you saw
-        damper = 0.2 if self.asymmetric else 0.5
+        # Calculate the "Stress" of the current logic
+        # Pred = (A * B) * (The learned stiffness of the connection)
+        learned_k = nc['k']
+        prediction = (na['x'] * nb['x']) * learned_k
+        self.current_error = prediction - nc['x']
+        
+        if abs(self.current_error) < 0.01:
+            if self.batch_queue:
+                p = self.batch_queue.popleft()
+                self.set_problem(p['a'], p['b'], p['c'])
+                return True
+            else:
+                self.running = False
+                self.add_log("Task Complete.")
+                return False
 
         if self.mode == 'inference':
-            move = event['f'] * damper
-            if self.distribution == 'individual':
-                move *= t_node['k']
-            
-            t_node['x'] += move
-            # CLAMPING: Prevent numbers from flying to 40,000
-            t_node['x'] = max(-1000, min(t_node['x'], 1000))
+            # Move C (The Output) to satisfy the learned K
+            # If error is positive (pred > C), we must increase C
+            move = self.current_error * 0.1
+            nc['x'] += move
+            nc['f'] = move
             
         elif self.mode == 'training':
-            # In training, we adjust the K coefficient based on the force
-            if self.distribution == 'individual':
-                 t_node['k'] = max(0.01, min(t_node['k'] - (abs(self.current_error) * 0.001), 2.0))
-        
-        self.trigger_cells() 
+            # C is locked. We must adjust K to make (A*B)*K = C
+            # Gradient Descent on the Stiffness
+            target_k = nc['x'] / (na['x'] * nb['x'] + 1e-9)
+            k_error = target_k - nc['k']
+            nc['k'] += k_error * 0.05 # Learning Rate
+            nc['f'] = k_error
+
         self.iteration += 1
         return True
 
@@ -125,60 +97,47 @@ engine = SimEngine()
 def run_loop():
     while True:
         if engine.running: engine.physics_step()
-        time.sleep(0.03)
+        time.sleep(0.05)
 
 threading.Thread(target=run_loop, daemon=True).start()
 
-# --- ROUTES (FastAPI) ---
 @app.get("/", response_class=HTMLResponse)
-async def get_ui():
-    return FileResponse("index.html")
+async def get_ui(): return FileResponse("index.html")
 
 @app.get("/state")
 async def get_state():
-    return {
-        'nodes': engine.nodes,
-        'error': engine.current_error,
-        'iteration': engine.iteration,
-        'logs': engine.logs,
-        'batch_count': len(engine.batch_queue)
-    }
-
-class ConfigModel(BaseModel):
-    mode: str
-    distribution: str
-    problem_type: str
-    asymmetric: bool
-
-@app.post("/apply_config")
-async def apply_config(cfg: ConfigModel):
-    engine.mode = cfg.mode
-    engine.distribution = cfg.distribution
-    engine.problem_type = cfg.problem_type
-    engine.asymmetric = cfg.asymmetric
-    engine.add_log("Config Updated.")
-    return {"success": True}
-
-@app.post("/single_run")
-async def single_run(data: dict):
-    engine.set_problem(float(data['target']))
-    engine.running = True
-    return {"success": True}
+    return {'nodes': engine.nodes, 'error': engine.current_error, 'iter': engine.iteration, 'logs': engine.logs}
 
-@app.post("/batch_run")
-async def batch_run(data: dict):
+@app.post("/config")
+async def config(data: dict):
+    engine.mode = data['mode']
+    engine.running = False
+    return {"ok": True}
+
+@app.post("/generate_factors")
+async def gen_factors(data: dict):
     engine.batch_queue.clear()
-    for _ in range(int(data['batch_size'])):
-        engine.batch_queue.append(round(random.uniform(float(data['val_min']), float(data['val_max'])), 2))
-    engine.set_problem(engine.batch_queue.popleft())
+    for _ in range(int(data['count'])):
+        a = random.randint(1, 10)
+        b = random.randint(1, 10)
+        engine.batch_queue.append({'a': a, 'b': b, 'c': a * b})
+    p = engine.batch_queue.popleft()
+    engine.set_problem(p['a'], p['b'], p['c'])
+    engine.running = True
+    return {"ok": True}
+
+@app.post("/test_custom")
+async def test_custom(data: dict):
+    engine.mode = 'inference'
+    engine.set_problem(data['a'], data['b'])
     engine.running = True
-    return {"success": True}
+    return {"ok": True}
 
 @app.post("/halt")
 async def halt():
     engine.running = False
     engine.reset()
-    return {"success": True}
+    return {"ok": True}
 
 if __name__ == "__main__":
     import uvicorn