Update app.py

app.py

@@ -1,134 +1,120 @@
 import os
 import time
-import math
 import collections
 import threading
-from flask import Flask, jsonify, request, send_file
-from flask_cors import CORS
+import random
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
 
-app = Flask(__name__)
-CORS(app)
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 class SimEngine:
     def __init__(self):
         self.nodes = {}       
-        self.cells =[]       
+        self.cells = []       
         self.buffer = collections.deque()
         self.running = False
-        
-        # State & Toggles
         self.mode = 'inference'       
         self.distribution = 'uniform' 
         self.problem_type = 'add'     
         self.asymmetric = False       
-        
-        # Dataset Batch Processor tracking
         self.batch_queue = collections.deque()
-        self.batch_results =[]
+        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)
         self.nodes = {
-            'A': {'x': 2.0, 'y': 1.0, 'z': 0.0, 'anchored': False, 'k': 1.0},
-            'B': {'x': 3.0, 'y': -1.0, 'z': 0.0, 'anchored': False, 'k': 0.8}, 
-            'C': {'x': 10.0, 'y': 0.0, 'z': 1.0, 'anchored': True,  'k': 1.0}  
+            '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}  
         }
-        self.cells =[{'id': 'Cell_1', 'a': 'A', 'b': 'B', 'c': 'C'}]
+        self.cells = [{'id': 'Cell_1', 'a': 'A', 'b': 'B', 'c': 'C'}]
         self.buffer.clear()
         self.batch_queue.clear()
-        self.logs =[]
+        self.logs = []
         self.iteration = 0
+        self.current_error = 0.0
 
     def add_log(self, msg):
         self.logs.insert(0, f"[{self.iteration}]: {msg}")
-        if len(self.logs) > 60: self.logs.pop()
+        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)
-        self.nodes['C']['anchored'] = True
-        
-        # In Training: C is goal. A and B are anchor/hints forcing structural (K) changes. 
-        if self.mode == 'training':
-            self.nodes['A']['anchored'] = True
-            self.nodes['B']['anchored'] = True
-        else: # Inference: C is goal. A and B float structurally to 'find' the factors
-            self.nodes['A']['anchored'] = False
-            self.nodes['B']['anchored'] = False
-
-        self.add_log(f"Loading Problem C={target_value} ({self.mode.upper()})")
+        # 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 generate_batch(self, size, start_range, end_range):
-        """Generates a dataset of Target C problems"""
-        self.batch_queue.clear()
-        self.batch_results.clear()
-        import random
-        for _ in range(size):
-            self.batch_queue.append(round(random.uniform(start_range, end_range), 2))
-        
-        self.add_log(f"=== BATCH CREATED: {size} Problems ===")
-        self.load_next_batch_item()
-
-    def load_next_batch_item(self):
-        if len(self.batch_queue) > 0:
-            next_c = self.batch_queue.popleft()
-            # Slight random offset so system resets dynamically between batch steps
-            self.nodes['A']['x'] += 0.01 
-            self.set_problem(next_c)
-            self.running = True
-        else:
-            self.running = False
-            self.add_log("=== BATCH RUN COMPLETE ===")
-
     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']
-            predictedC = (valA + valB) if self.problem_type == 'add' else (valA * valB)
             
-            error = predictedC - valC 
+            # Logic calculation
+            pred = (valA + valB) if self.problem_type == 'add' else (valA * valB)
+            self.current_error = pred - valC 
             
-            if abs(error) > 0.05: 
-                # Network splits pressure
-                self.buffer.append({'target': cell['a'], 'error_vector': error, 'cell': cell})
-                self.buffer.append({'target': cell['b'], 'error_vector': error, 'cell': cell})
+            # 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
 
     def physics_step(self):
-        # Handle Batch Loading if Equilibrium Reached
-        if len(self.buffer) == 0:
-            if self.current_target is not None and self.running:
-                 self.add_log(f"Equilibrium found for C={self.current_target}.")
+        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
-                 time.sleep(0.5) # small visualization pause between batch items
-                 self.load_next_batch_item()
+                 if self.batch_queue:
+                     time.sleep(0.5)
+                     self.set_problem(self.batch_queue.popleft())
+                 else:
+                     self.running = False
             return False 
         
         event = self.buffer.popleft()
-        t_id, err = event['target'], event['error_vector']
-        t_node = self.nodes[t_id]
+        t_node = self.nodes[event['target']]
 
         if t_node['anchored'] and self.mode != 'training': return True 
-
-        # Asymmetric Retroactive Force
-        direction_damper = 0.4 if self.asymmetric else 1.0
+        
+        # Dampening to prevent the explosion you saw
+        damper = 0.2 if self.asymmetric else 0.5
 
         if self.mode == 'inference':
-            base_force = (-err * 0.02 * direction_damper)
-            if self.distribution == 'uniform':
-                t_node['x'] += base_force 
-                t_node['y'] -= base_force * 0.08
-            elif self.distribution == 'individual':
-                t_node['x'] += base_force * t_node['k']
+            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))
             
         elif self.mode == 'training':
-            base_grad = abs(err) * 0.01 * direction_damper
+            # In training, we adjust the K coefficient based on the force
             if self.distribution == 'individual':
-                 t_node['k'] -= base_grad 
-                 t_node['k'] = max(0.001, min(t_node['k'], 5.0)) # bounding constraints for coefficients
+                 t_node['k'] = max(0.01, min(t_node['k'] - (abs(self.current_error) * 0.001), 2.0))
         
         self.trigger_cells() 
         self.iteration += 1
@@ -139,61 +125,61 @@ engine = SimEngine()
 def run_loop():
     while True:
         if engine.running: engine.physics_step()
-        time.sleep(0.02)
+        time.sleep(0.03)
 
 threading.Thread(target=run_loop, daemon=True).start()
 
-# --- HOSTING ENDPOINTS ---
-@app.route('/')
-def home():
-    """Hugging Face Space loads this UI natively"""
-    return send_file("index.html")
+# --- ROUTES (FastAPI) ---
+@app.get("/", response_class=HTMLResponse)
+async def get_ui():
+    return FileResponse("index.html")
 
-@app.route('/state', methods=['GET'])
-def get_state():
-    return jsonify({
+@app.get("/state")
+async def get_state():
+    return {
         'nodes': engine.nodes,
-        'buffer_size': len(engine.buffer),
+        'error': engine.current_error,
         'iteration': engine.iteration,
         'logs': engine.logs,
-        'batch_size': len(engine.batch_queue)
-    })
-
-@app.route('/apply_config', methods=['POST'])
-def config():
-    data = request.json
-    engine.mode = data.get('mode', engine.mode)
-    engine.distribution = data.get('distribution', engine.distribution)
-    engine.problem_type = data.get('problem_type', engine.problem_type)
-    engine.asymmetric = data.get('asymmetric', engine.asymmetric)
-    engine.add_log(f"CONFIG UPDATED: mode={engine.mode}")
-    return jsonify(success=True)
-
-@app.route('/single_run', methods=['POST'])
-def single_run():
-    data = request.json
-    engine.set_problem(float(data.get('target', 10.0)))
+        '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 jsonify(success=True)
+    return {"success": True}
 
-@app.route('/batch_run', methods=['POST'])
-def batch_run():
-    data = request.json
-    engine.running = False
-    size = int(data.get('batch_size', 10))
-    vmin = float(data.get('val_min', -50.0))
-    vmax = float(data.get('val_max', 50.0))
-    engine.generate_batch(size, vmin, vmax)
-    return jsonify(success=True)
-
-@app.route('/halt', methods=['POST'])
-def halt_sys():
-    engine.running = False
-    engine.buffer.clear()
+@app.post("/batch_run")
+async def batch_run(data: dict):
     engine.batch_queue.clear()
-    engine.add_log("=== HARD HALT EXEC === Queues Cleared.")
-    return jsonify(success=True)
+    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())
+    engine.running = True
+    return {"success": True}
+
+@app.post("/halt")
+async def halt():
+    engine.running = False
+    engine.reset()
+    return {"success": True}
 
-if __name__ == '__main__':
-    # Binds correctly to hugging face's public 7860 Port Space Requirements
-    app.run(host='0.0.0.0', port=7860)
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)