Update app.py

app.py

@@ -1,7 +1,9 @@
+import os
 import time
+import math
 import collections
 import threading
-from flask import Flask, jsonify, request
+from flask import Flask, jsonify, request, send_file
 from flask_cors import CORS
 
 app = Flask(__name__)
@@ -14,95 +16,120 @@ class SimEngine:
         self.buffer = collections.deque()
         self.running = False
         
-        # Dial Dashboard State
-        self.mode = 'inference'       # 'inference' (free A&B) or 'training' (clamped A&B)
-        self.distribution = 'uniform' # 'uniform' (50/50 split) or 'individual' (vertex k-values)
-        self.problem_type = 'add'     # 'add' or 'mult'
-        self.asymmetric = False       # dampen retroactive pushes to prevent exploding values
+        # 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.current_target = None
         
         self.reset()
 
     def reset(self):
-        # Initialize semantic 'embeddings' in 3D latent space. X is the logic value for this simple PoC.
         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}  
         }
-        # One mesh cell connects all 3 constraints
         self.cells =[{'id': 'Cell_1', 'a': 'A', 'b': 'B', 'c': 'C'}]
         self.buffer.clear()
+        self.batch_queue.clear()
         self.logs =[]
         self.iteration = 0
 
     def add_log(self, msg):
-        self.logs.insert(0, f"Iter {self.iteration}: {msg}")
-        if len(self.logs) > 50: self.logs.pop() # Keep log buffer clean
+        self.logs.insert(0, f"[{self.iteration}]: {msg}")
+        if len(self.logs) > 60: self.logs.pop()
 
     def set_problem(self, target_value):
-        # Target objective is permanently clamped
+        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
-            self.add_log(f"Training initiated. C clamped to: {target_value}")
-        else:
+        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"Inference initiated. Free mesh calculating towards: {target_value}")
 
-        self.trigger_cells() # Jumpstart event cascade
+        self.add_log(f"Loading Problem C={target_value} ({self.mode.upper()})")
+        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):
-        """Cell mathematical constraint check. Pushes structural 'error' to buffer if not solved."""
         for cell in self.cells:
             na, nb, nc = self.nodes[cell['a']], self.nodes[cell['b']], self.nodes[cell['c']]
             
-            # Using basic arithmetic logic in Dim X for visibility
             valA, valB, valC = na['x'], nb['x'], nc['x']
             predictedC = (valA + valB) if self.problem_type == 'add' else (valA * valB)
             
             error = predictedC - valC 
             
-            if abs(error) > 0.05: # Yield Limit threshold
-                # Add retroactive tension to A and B
+            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})
 
     def physics_step(self):
-        if not self.buffer: return False # Queue is empty, logic equilibrium reached.
+        # 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}.")
+                 self.current_target = None
+                 time.sleep(0.5) # small visualization pause between batch items
+                 self.load_next_batch_item()
+            return False 
         
         event = self.buffer.popleft()
         t_id, err = event['target'], event['error_vector']
         t_node = self.nodes[t_id]
 
-        # Ignore locked objects
-        if t_node['anchored'] and self.mode != 'training':
-            return True 
+        if t_node['anchored'] and self.mode != 'training': return True 
 
-        # Implement Asymmetry Rule (Stop resonance explosions)
-        direction_damper = 0.3 if self.asymmetric else 1.0
+        # Asymmetric Retroactive Force
+        direction_damper = 0.4 if self.asymmetric else 1.0
 
         if self.mode == 'inference':
-            # --- Adapt Topology Geometry ---
-            # Moves to minimize structural stress based on dials
             base_force = (-err * 0.02 * direction_damper)
             if self.distribution == 'uniform':
                 t_node['x'] += base_force 
-                t_node['y'] -= base_force * 0.1 # visual spatial twisting
+                t_node['y'] -= base_force * 0.08
             elif self.distribution == 'individual':
                 t_node['x'] += base_force * t_node['k']
             
         elif self.mode == 'training':
-            # --- Learn Structural Stiffness 'K' ---
-            # Node geometry is locked. System adjusts how elastic the point is.
-            base_grad = abs(err) * 0.005 * direction_damper
+            base_grad = abs(err) * 0.01 * direction_damper
             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
         
-        # Move cascaded, so tell network to re-measure stress.
         self.trigger_cells() 
         self.iteration += 1
         return True
@@ -112,11 +139,15 @@ engine = SimEngine()
 def run_loop():
     while True:
         if engine.running: engine.physics_step()
-        time.sleep(0.015) # Simulated latency/Buffer cycle speed
+        time.sleep(0.02)
 
 threading.Thread(target=run_loop, daemon=True).start()
 
-# --------- INTERFACE API ---------
+# --- HOSTING ENDPOINTS ---
+@app.route('/')
+def home():
+    """Hugging Face Space loads this UI natively"""
+    return send_file("index.html")
 
 @app.route('/state', methods=['GET'])
 def get_state():
@@ -125,26 +156,44 @@ def get_state():
         'buffer_size': len(engine.buffer),
         'iteration': engine.iteration,
         'logs': engine.logs,
-        'mode': engine.mode
+        'batch_size': len(engine.batch_queue)
     })
 
 @app.route('/apply_config', methods=['POST'])
 def config():
     data = request.json
-    engine.running = False # Pause briefly for logic change
-    
     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)
-    target = data.get('target', 10.0)
-    
-    engine.set_problem(target)
-    engine.add_log(f"[DIALS CHANGED]: phase={engine.mode}, split={engine.distribution}, type={engine.problem_type}, async={engine.asymmetric}")
-    
-    engine.running = data.get('is_running', False)
+    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)))
+    engine.running = True
+    return jsonify(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()
+    engine.batch_queue.clear()
+    engine.add_log("=== HARD HALT EXEC === Queues Cleared.")
     return jsonify(success=True)
 
 if __name__ == '__main__':
-    print("Semantic Latent Topography Core started on :5000.")
-    app.run(port=7860, debug=True, use_reloader=False)
+    # Binds correctly to hugging face's public 7860 Port Space Requirements
+    app.run(host='0.0.0.0', port=7860)