Update app.py

app.py

@@ -6,7 +6,6 @@ import random
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
 
 app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
@@ -16,30 +15,25 @@ class SimEngine:
         self.nodes = {}       
         self.running = False
         self.mode = 'inference'       
-        self.problem_type = 'housing' # add, mult, housing, sub, div
-        self.mesh_depth = 2
+        self.architecture = 'additive' # How the mesh physically works
+        self.dataset_type = 'housing'  # What data we are forcing into it
         self.batch_queue = collections.deque()
-        self.logs = []
+        self.logs =[]
         self.iteration = 0
         self.current_error = 0.0
         self.reset()
 
     def reset(self):
-        self.nodes = {}
-        # Fixed Anchors
-        self.nodes['A'] = {'x': 1.0, 'y': 2.0, 'anchored': True, 'k': 1.0}
-        self.nodes['B'] = {'x': 1.0, 'y': -2.0, 'anchored': True, 'k': 1.0}
-        self.nodes['C'] = {'x': 1.0, 'y': 0.0, 'anchored': False, 'k': 1.0}
-
-        # Generate Multicellular Mesh between A->C and B->C
-        for i in range(self.mesh_depth):
-            self.nodes[f'H_AC_{i}'] = {'x': random.uniform(0, 1), 'y': 1.0, 'anchored': False, 'k': random.uniform(0.1, 1.0)}
-            self.nodes[f'H_BC_{i}'] = {'x': random.uniform(0, 1), 'y': -1.0, 'anchored': False, 'k': random.uniform(0.1, 1.0)}
-
+        # A & B are inputs, C is output. K-factors are the elasticity of the connections.
+        self.nodes = {
+            'A': {'x': 2.0, 'y': 2.0, 'anchored': True, 'k': random.uniform(0.1, 1.0)},
+            'B': {'x': 3.0, 'y': -2.0, 'anchored': True, 'k': random.uniform(0.1, 1.0)},
+            'C': {'x': 5.0, 'y': 0.0, 'anchored': False, 'k': 1.0}
+        }
         self.batch_queue.clear()
-        self.logs = []
+        self.logs =[]
         self.iteration = 0
-        self.add_log(f"Mesh Reset: Depth {self.mesh_depth}")
+        self.current_error = 0.0
 
     def add_log(self, msg):
         self.logs.insert(0, f"[{self.iteration}]: {msg}")
@@ -53,23 +47,21 @@ class SimEngine:
             self.nodes['C']['anchored'] = True
         else:
             self.nodes['C']['anchored'] = False
-            self.nodes['C']['x'] = random.uniform(0, 10)
+            # Start C at zero to watch it drift to the answer
+            self.nodes['C']['x'] = 0.0 
 
     def physics_step(self):
-        # 1. Forward Pass: Summing the chains
-        # We simulate the "Law" as a chain of K-stiffness through the hidden cells
-        val_ac = self.nodes['A']['x']
-        for i in range(self.mesh_depth):
-            val_ac *= self.nodes[f'H_AC_{i}']['k']
+        na, nb, nc = self.nodes['A'], self.nodes['B'], self.nodes['C']
         
-        val_bc = self.nodes['B']['x']
-        for i in range(self.mesh_depth):
-            val_bc *= self.nodes[f'H_BC_{i}']['k']
+        # 1. CORE ARCHITECTURE LOGIC (Completely blind to the dataset)
+        if self.architecture == 'additive':
+            prediction = (na['x'] * na['k']) + (nb['x'] * nb['k'])
+        else: # multiplicative
+            prediction = (na['x'] * na['k']) * (nb['x'] * nb['k'])
 
-        # The relationship is the sum of the two mesh flows
-        prediction = val_ac + val_bc
-        self.current_error = prediction - self.nodes['C']['x']
+        self.current_error = prediction - nc['x']
 
+        # Check for convergence
         if abs(self.current_error) < 0.05:
             if self.batch_queue:
                 p = self.batch_queue.popleft()
@@ -79,16 +71,23 @@ class SimEngine:
                 self.running = False
                 return False
 
-        # 2. Back-Propagating Tension
+        # 2. RESOLVING TENSION (Push / Pull)
         if self.mode == 'inference':
-            # Drift C to meet the mesh output
-            self.nodes['C']['x'] += self.current_error * 0.1
+            # Shift the output node C until tension reaches zero
+            nc['x'] += self.current_error * 0.1
+            
         elif self.mode == 'training':
-            # Update K factors in the mesh to minimize error
-            adjustment = self.current_error * 0.01
-            for i in range(self.mesh_depth):
-                self.nodes[f'H_AC_{i}']['k'] -= adjustment
-                self.nodes[f'H_BC_{i}']['k'] -= adjustment
+            # The structure is locked. Tension deforms the K (Stiffness) factors.
+            lr = 0.01 # Learning elasticity rate
+            
+            if self.architecture == 'additive':
+                # Force distributes proportionally based on node input value
+                na['k'] -= self.current_error * na['x'] * lr
+                nb['k'] -= self.current_error * nb['x'] * lr
+            else:
+                # Chain rule tension for multiplication
+                na['k'] -= self.current_error * (nb['x'] * nb['k']) * na['x'] * (lr * 0.01)
+                nb['k'] -= self.current_error * (na['x'] * na['k']) * nb['x'] * (lr * 0.01)
 
         self.iteration += 1
         return True
@@ -112,24 +111,31 @@ async def get_state():
 @app.post("/config")
 async def config(data: dict):
     engine.mode = data['mode']
-    engine.mesh_depth = int(data['depth'])
-    engine.problem_type = data['type']
+    engine.architecture = data['architecture']
+    engine.dataset_type = data['dataset']
     engine.running = False
     engine.reset()
+    engine.add_log(f"Arch: {engine.architecture} | Data: {engine.dataset_type}")
     return {"ok": True}
 
 @app.post("/generate")
 async def generate(data: dict):
     engine.batch_queue.clear()
-    for _ in range(20):
-        a = random.uniform(1, 10)
-        b = random.uniform(1, 10)
-        # Housing Rule: Location(a) * 2 + Size(b) * 0.5 = Price(c)
-        if engine.problem_type == 'housing': c = (a * 2.5) + (b * 1.2)
-        elif engine.problem_type == 'sub': c = a - b
-        elif engine.problem_type == 'div': c = a / (b + 0.1)
-        else: c = a + b
+    for _ in range(30):
+        a = random.uniform(2, 10)
+        b = random.uniform(2, 10)
+        
+        # This is the dataset environment. The mesh DOES NOT know these rules.
+        # It must learn them by adjusting K_a and K_b.
+        if engine.dataset_type == 'housing': 
+            c = (a * 2.5) + (b * 1.2) # Hidden weights: 2.5 and 1.2
+        elif engine.dataset_type == 'subtraction': 
+            c = (a * 1.0) + (b * -1.0) # Hidden weights: 1.0 and -1.0
+        elif engine.dataset_type == 'multiplication': 
+            c = a * b
+            
         engine.batch_queue.append({'a': a, 'b': b, 'c': c})
+        
     p = engine.batch_queue.popleft()
     engine.set_problem(p['a'], p['b'], p['c'])
     engine.running = True