Upgrade to CTM v2.0 - Full PyTorch implementation with online training

app.py

@@ -1,85 +1,250 @@
 """
-CTM Nervous System Server - Continuous Thought Machine for Hypergraph Maintenance
-===================================================================================
-Implementation of the definitive proposal: CTM as Nervous System for ART-17 Hypergraph.
+CTM Nervous System Server v2.0 - Full PyTorch Implementation
+=============================================================
+Continuous Thought Machine for ART-17 Hypergraph Coherence Generation
 
-Endpoints:
-- /sense_snn: Process 72D SNN input with NLM-style processing
-- /reason_hypergraph: Reason about hypergraph context, propose edges
-- /validate_physics: Validate proposals against 5 physics losses
-- /dream: Offline consolidation with T=500+ ticks
-- /calibrate_stdp: Suggest STDP weight adjustments from sync matrix
-- /health: Health check endpoint
+PURPOSE (from skills):
+1. REGULACIÓN: Calibrar pesos STDP de las 16 dendritas
+2. COHERENCIA: Generar hipergrafos deterministas
+3. RAZONAMIENTO: Motor de inferencia activa (internal ticks)
+4. SINCRONIZACIÓN: Representación via Neural Synchronization
+
+TRAINING STRATEGY:
+- Progressive online learning with use
+- Integrates with Brain server (Qwen + VL-JEPA) for semantic grounding
+- Automatic checkpoint saving
 
 Based on: arXiv:2505.05522 (Continuous Thought Machines - Sakana AI)
+Adapted for: ART-17 Dendrite Regulation & Hypergraph Generation
 """
 
 import gradio as gr
 import numpy as np
 import json
-from typing import List, Dict, Any, Optional
 import os
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+# ============================================================================
+# PYTORCH IMPORTS WITH FALLBACK
+# ============================================================================
+try:
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    TORCH_AVAILABLE = True
+    DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"🔧 PyTorch available. Device: {DEVICE}")
+except ImportError:
+    TORCH_AVAILABLE = False
+    DEVICE = "cpu"
+    print("⚠️ PyTorch not available. Using simplified NumPy fallback.")
+
+# ============================================================================
+# FULL CTM IMPORT (with fallback to simplified)
+# ============================================================================
+if TORCH_AVAILABLE:
+    try:
+        from models.ctm import ContinuousThoughtMachine
+        from models.modules import SynapseUNET, SuperLinear
+        from utils.losses import image_classification_loss
+        CTM_FULL = True
+        print("✅ Full CTM model loaded from models/ctm.py")
+    except ImportError as e:
+        CTM_FULL = False
+        print(f"⚠️ Could not import full CTM: {e}. Using simplified.")
+else:
+    CTM_FULL = False
 
 # ============================================================================
-# SIMPLIFIED CTM SIMULATION (CPU-only for Hugging Face free tier)
+# CONFIGURATION FOR ART-17 INTEGRATION
 # ============================================================================
+CONFIG = {
+    # CTM Architecture (matching ART-17)
+    "iterations": 50,           # T internal ticks
+    "d_model": 256,             # Latent dimension
+    "d_input": 72,              # Input from SNN (72D)
+    "memory_length": 16,        # History length (16 dendrites)
+    "n_synch_out": 32,          # Output sync neurons
+    "n_synch_action": 16,       # Action sync neurons
+    "out_dims": 16,             # Output: 16 dendrite adjustments
+    
+    # Training
+    "learning_rate": 1e-4,
+    "weight_decay": 1e-5,
+    "checkpoint_dir": "checkpoints",
+    "auto_save_every": 100,     # Save every N forward passes
+    
+    # Integration
+    "brain_server_url": "https://elliotasdasdasfasas-brain.hf.space",
+    
+    # Physics validation
+    "physics_thresholds": {
+        "P_max": 1000.0,
+        "v_max": 100.0,
+        "T_dew": 15.0,
+        "T_amb": 25.0
+    }
+}
 
-class SimplifiedCTM:
+# ============================================================================
+# FULL CTM WRAPPER FOR ART-17
+# ============================================================================
+class CTM_ART17:
     """
-    Simplified CTM for CPU-only environment.
-    Simulates the key mechanisms without full PyTorch model.
+    Full Continuous Thought Machine adapted for ART-17.
+    
+    Key mechanisms from paper:
+    1. NLMs (Neuron-Level Models) - Each neuron processes its own history
+    2. Neural Synchronization - Representation is S = Z·Z^T
+    3. Adaptive Compute - Can halt early when confident
+    
+    Purpose in ART-17:
+    - Regulate 16 dendrite STDP weights
+    - Generate coherent hypergraph edges
+    - Serve as "nervous system" for the whole system
     """
     
-    def __init__(self, d_model: int = 256, memory_length: int = 16, n_ticks: int = 50):
-        self.d_model = d_model
-        self.memory_length = memory_length
-        self.n_ticks = n_ticks
-        
-        # Initialize state
-        self.state_trace = np.zeros((d_model, memory_length))
-        self.activated_state = np.random.randn(d_model) * 0.1
-        
-        # NLM weights (simplified: one weight matrix per "neuron group")
-        self.nlm_weights = np.random.randn(16, memory_length) * 0.1  # 16 groups for 16 dendrites
-        
-    def compute_sync_matrix(self, z: np.ndarray) -> np.ndarray:
-        """S^t = Z · Z^T (normalized)"""
-        z_norm = z / (np.linalg.norm(z) + 1e-8)
-        S = np.outer(z_norm, z_norm)
-        return S
-    
-    def compute_certainty(self, predictions: np.ndarray) -> float:
-        """Certainty = 1 - normalized entropy"""
-        probs = np.abs(predictions) / (np.sum(np.abs(predictions)) + 1e-8)
-        probs = np.clip(probs, 1e-10, 1.0)
-        entropy = -np.sum(probs * np.log(probs))
-        max_entropy = np.log(len(probs))
-        normalized_entropy = entropy / (max_entropy + 1e-8)
-        return float(1.0 - normalized_entropy)
-    
-    def process_ticks(self, input_features: np.ndarray, n_ticks: Optional[int] = None) -> Dict:
-        """Run T internal ticks and return sync matrix + certainty"""
-        n_ticks = n_ticks or self.n_ticks
-        
-        # Ensure input is right size
-        if len(input_features) < self.d_model:
-            input_features = np.pad(input_features, (0, self.d_model - len(input_features)))
+    def __init__(self, config: dict):
+        self.config = config
+        self.forward_count = 0
+        self.training_samples = []
+        
+        if CTM_FULL and TORCH_AVAILABLE:
+            self._init_full_ctm()
         else:
-            input_features = input_features[:self.d_model]
+            self._init_simplified_ctm()
+    
+    def _init_full_ctm(self):
+        """Initialize full PyTorch CTM model."""
+        self.model = ContinuousThoughtMachine(
+            iterations=self.config["iterations"],
+            d_model=self.config["d_model"],
+            d_input=self.config["d_input"],
+            heads=4,
+            n_synch_out=self.config["n_synch_out"],
+            n_synch_action=self.config["n_synch_action"],
+            synapse_depth=2,
+            memory_length=self.config["memory_length"],
+            deep_nlms=True,
+            memory_hidden_dims=32,
+            do_layernorm_nlm=False,
+            backbone_type='none',
+            positional_embedding_type='none',
+            out_dims=self.config["out_dims"],
+            prediction_reshaper=[self.config["out_dims"]],
+            dropout=0.1,
+            neuron_select_type='random-pairing'
+        ).to(DEVICE)
+        
+        # Dummy forward to initialize lazy modules
+        with torch.no_grad():
+            dummy = torch.randn(1, self.config["d_input"], device=DEVICE)
+            dummy = dummy.unsqueeze(-1).unsqueeze(-1)  # [1, 72, 1, 1]
+            try:
+                _ = self.model(dummy)
+            except Exception as e:
+                print(f"⚠️ Lazy init failed: {e}")
+        
+        self.model.eval()
+        self.optimizer = torch.optim.AdamW(
+            self.model.parameters(),
+            lr=self.config["learning_rate"],
+            weight_decay=self.config["weight_decay"]
+        )
+        
+        self.is_full = True
+        param_count = sum(p.numel() for p in self.model.parameters())
+        print(f"✅ Full CTM initialized: {param_count:,} parameters")
+        
+        # Try to load existing checkpoint
+        self._load_checkpoint()
+    
+    def _init_simplified_ctm(self):
+        """Initialize simplified NumPy CTM (fallback)."""
+        self.d_model = self.config["d_model"]
+        self.memory_length = self.config["memory_length"]
+        self.n_ticks = self.config["iterations"]
+        
+        # State traces
+        self.state_trace = np.zeros((self.d_model, self.memory_length))
+        self.activated_state = np.random.randn(self.d_model) * 0.1
+        
+        # NLM weights (simplified: 16 groups for 16 dendrites)
+        self.nlm_weights = np.random.randn(16, self.memory_length) * 0.1
+        
+        self.is_full = False
+        print("✅ Simplified CTM initialized (NumPy fallback)")
+    
+    def forward(self, input_72d: np.ndarray, n_ticks: Optional[int] = None) -> Dict:
+        """
+        Process input through CTM.
+        
+        Args:
+            input_72d: 72D input from SNN
+            n_ticks: Override number of internal ticks
+            
+        Returns:
+            Dict with predictions, certainty, sync matrix
+        """
+        n_ticks = n_ticks or self.config["iterations"]
+        self.forward_count += 1
+        
+        if self.is_full:
+            return self._forward_full(input_72d, n_ticks)
+        else:
+            return self._forward_simplified(input_72d, n_ticks)
+    
+    def _forward_full(self, input_72d: np.ndarray, n_ticks: int) -> Dict:
+        """Forward pass with full PyTorch CTM."""
+        # Prepare tensor
+        x = torch.tensor(input_72d, dtype=torch.float32, device=DEVICE)
+        if len(x.shape) == 1:
+            x = x.unsqueeze(0)  # Add batch dim
+        x = x.unsqueeze(-1).unsqueeze(-1)  # [B, 72, 1, 1]
+        
+        with torch.no_grad():
+            predictions, certainties, sync_out = self.model(x)
+        
+        # Extract results
+        final_pred = predictions[:, :, -1].cpu().numpy()[0]  # Last tick [16]
+        final_cert = certainties[:, 1, -1].cpu().numpy()[0]  # 1-entropy
+        
+        # Find tick with highest certainty
+        best_tick_idx = certainties[:, 1, :].argmax(dim=-1)[0].item()
+        best_pred = predictions[:, :, best_tick_idx].cpu().numpy()[0]
+        
+        # Sync matrix for hypergraph edge proposals
+        sync_matrix = sync_out.cpu().numpy()[0] if sync_out is not None else None
+        
+        return {
+            "predictions": final_pred.tolist(),
+            "best_predictions": best_pred.tolist(),
+            "certainty": float(final_cert),
+            "best_tick": int(best_tick_idx),
+            "ticks_used": n_ticks,
+            "sync_matrix": sync_matrix.tolist() if sync_matrix is not None else None,
+            "model": "ContinuousThoughtMachine (Full PyTorch)"
+        }
+    
+    def _forward_simplified(self, input_72d: np.ndarray, n_ticks: int) -> Dict:
+        """Forward pass with simplified NumPy CTM."""
+        # Pad to d_model
+        input_256 = np.zeros(self.d_model)
+        input_256[:min(len(input_72d), self.d_model)] = input_72d[:self.d_model]
         
         certainties = []
-        sync_matrices = []
         
         for t in range(n_ticks):
-            # Simulate synapse update
-            combined = np.concatenate([self.activated_state, input_features[:self.d_model//2]])
+            # Synapse update (simplified)
+            combined = np.concatenate([self.activated_state, input_256[:self.d_model//2]])
             pre_activation = np.tanh(combined[:self.d_model] * 0.1 + np.random.randn(self.d_model) * 0.01)
             
-            # Update trace
+            # Update trace (memory)
             self.state_trace = np.roll(self.state_trace, -1, axis=1)
             self.state_trace[:, -1] = pre_activation
             
-            # Simulate NLM (simplified)
+            # NLM processing (simplified: 16 groups)
             post_activation = np.zeros(self.d_model)
             group_size = self.d_model // 16
             for g in range(16):
@@ -91,50 +256,151 @@ class SimplifiedCTM:
             
             self.activated_state = post_activation
             
-            # Compute sync and certainty
-            sync = self.compute_sync_matrix(self.activated_state)
-            cert = self.compute_certainty(self.activated_state)
+            # Compute certainty
+            probs = np.abs(self.activated_state) / (np.sum(np.abs(self.activated_state)) + 1e-8)
+            probs = np.clip(probs, 1e-10, 1.0)
+            entropy = -np.sum(probs * np.log(probs))
+            max_entropy = np.log(len(probs))
+            certainties.append(float(1.0 - entropy / (max_entropy + 1e-8)))
+        
+        # Best tick
+        best_tick_idx = int(np.argmax(certainties))
+        
+        # Sync matrix
+        z_norm = self.activated_state / (np.linalg.norm(self.activated_state) + 1e-8)
+        sync_matrix = np.outer(z_norm, z_norm)
+        
+        # Predictions (first 16 elements of activated state)
+        predictions = self.activated_state[:16].tolist()
+        
+        return {
+            "predictions": predictions,
+            "best_predictions": predictions,
+            "certainty": certainties[-1],
+            "best_tick": best_tick_idx,
+            "ticks_used": n_ticks,
+            "sync_matrix": sync_matrix[:16, :16].tolist(),
+            "model": "SimplifiedCTM (NumPy fallback)"
+        }
+    
+    def train_step(self, input_72d: np.ndarray, target_16d: np.ndarray, 
+                   physics_loss: float = 0.0) -> Dict:
+        """
+        Online training step.
+        
+        Args:
+            input_72d: Input from SNN
+            target_16d: Target dendrite adjustments (ground truth)
+            physics_loss: Current physics loss for weighting
             
-            sync_matrices.append(sync)
-            certainties.append(cert)
+        Returns:
+            Dict with loss and gradient info
+        """
+        if not self.is_full or not TORCH_AVAILABLE:
+            return {"status": "skip", "reason": "Training requires full PyTorch CTM"}
+        
+        self.model.train()
+        
+        # Prepare tensors
+        x = torch.tensor(input_72d, dtype=torch.float32, device=DEVICE)
+        x = x.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)  # [1, 72, 1, 1]
+        y = torch.tensor(target_16d, dtype=torch.float32, device=DEVICE).unsqueeze(0)
+        
+        # Forward
+        predictions, certainties, _ = self.model(x)
         
-        # Find best ticks (min-loss proxy: max certainty)
-        best_tick = int(np.argmax(certainties))
+        # Loss: dendrite_regulation_loss
+        # predictions: [B, 16, T], y: [B, 16]
+        y_exp = y.unsqueeze(-1).expand(-1, -1, predictions.size(-1))  # [B, 16, T]
+        mse_per_tick = F.mse_loss(predictions, y_exp, reduction='none').mean(dim=1)  # [B, T]
+        
+        # Select best tick (min loss) and most certain tick
+        loss_min_idx = mse_per_tick.argmin(dim=1)  # [B]
+        loss_cert_idx = certainties[:, 1, :].argmax(dim=1)  # [B]
+        
+        batch_idx = torch.arange(predictions.size(0), device=DEVICE)
+        loss_min = mse_per_tick[batch_idx, loss_min_idx].mean()
+        loss_cert = mse_per_tick[batch_idx, loss_cert_idx].mean()
+        
+        # Combined loss with physics penalty
+        mse_loss = (loss_min + loss_cert) / 2
+        physics_penalty = physics_loss * 0.1
+        total_loss = mse_loss + physics_penalty
+        
+        # Backward
+        self.optimizer.zero_grad()
+        total_loss.backward()
+        torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
+        self.optimizer.step()
+        
+        self.model.eval()
+        
+        # Auto-save checkpoint
+        if self.forward_count % self.config["auto_save_every"] == 0:
+            self._save_checkpoint()
         
         return {
-            "final_sync_matrix": sync_matrices[-1].tolist(),
-            "best_sync_matrix": sync_matrices[best_tick].tolist(),
-            "certainties": certainties,
-            "final_certainty": float(certainties[-1]),
-            "max_certainty": float(max(certainties)),
-            "best_tick": best_tick,
-            "ticks_used": n_ticks
+            "status": "trained",
+            "loss": float(total_loss.item()),
+            "mse_loss": float(mse_loss.item()),
+            "physics_penalty": float(physics_penalty),
+            "best_tick": int(loss_cert_idx[0].item())
         }
+    
+    def _save_checkpoint(self):
+        """Save model checkpoint."""
+        if not self.is_full:
+            return
+        
+        os.makedirs(self.config["checkpoint_dir"], exist_ok=True)
+        path = os.path.join(self.config["checkpoint_dir"], "ctm_art17_latest.pt")
+        
+        torch.save({
+            "model_state_dict": self.model.state_dict(),
+            "optimizer_state_dict": self.optimizer.state_dict(),
+            "forward_count": self.forward_count,
+            "timestamp": datetime.now().isoformat()
+        }, path)
+        print(f"💾 Checkpoint saved: {path}")
+    
+    def _load_checkpoint(self):
+        """Load model checkpoint if exists."""
+        path = os.path.join(self.config["checkpoint_dir"], "ctm_art17_latest.pt")
+        if os.path.exists(path):
+            try:
+                checkpoint = torch.load(path, map_location=DEVICE)
+                self.model.load_state_dict(checkpoint["model_state_dict"])
+                self.optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
+                self.forward_count = checkpoint.get("forward_count", 0)
+                print(f"✅ Checkpoint loaded: {path}")
+            except Exception as e:
+                print(f"⚠️ Could not load checkpoint: {e}")
 
-# Global CTM instance
-ctm = SimplifiedCTM(d_model=256, memory_length=16, n_ticks=50)
+# ============================================================================
+# GLOBAL CTM INSTANCE
+# ============================================================================
+ctm = CTM_ART17(CONFIG)
 
 # ============================================================================
 # PHYSICS VALIDATION (from SNN Omega-21)
 # ============================================================================
-
 def validate_physics(trajectory: List[float], params: Dict) -> Dict:
-    """Validate against 5 physics losses from SNN Omega-21"""
+    """Validate against 5 physics losses from SNN Omega-21."""
     trajectory = np.array(trajectory)
     
     # L_energy: Energy conservation
     energy = np.sum(trajectory ** 2)
-    P_max = params.get("P_max", 1000.0)
+    P_max = params.get("P_max", CONFIG["physics_thresholds"]["P_max"])
     L_energy = float(max(0, energy - P_max) ** 2)
     
     # L_thermo: Thermodynamics (dew point check)
-    T_dew = params.get("T_dew", 15.0)
-    T_amb = params.get("T_amb", 25.0)
+    T_dew = params.get("T_dew", CONFIG["physics_thresholds"]["T_dew"])
+    T_amb = params.get("T_amb", CONFIG["physics_thresholds"]["T_amb"])
     L_thermo = float(max(0, T_dew - T_amb) ** 2)
     
     # L_causal: Causality (velocity limit)
     velocity = np.diff(trajectory) if len(trajectory) > 1 else np.array([0])
-    v_max = params.get("v_max", 100.0)
+    v_max = params.get("v_max", CONFIG["physics_thresholds"]["v_max"])
     L_causal = float(np.sum(np.maximum(0, np.abs(velocity) - v_max) ** 2))
     
     # L_conserv: Flux conservation
@@ -165,49 +431,54 @@ def validate_physics(trajectory: List[float], params: Dict) -> Dict:
 
 def sense_snn(snn_json: str) -> str:
     """
-    /sense_snn - Process 72D SNN input
-    Input: JSON with dendrite values
-    Output: Coherent features + anomalies
+    /sense_snn - Process 72D SNN input through CTM
+    
+    Input: JSON with dendrite values or 72D vector
+    Output: Coherent features, certainty, sync matrix
     """
     try:
         data = json.loads(snn_json)
         
-        # Extract 72D vector (or create from dendrites)
+        # Extract 72D vector
         if "vector_72d" in data:
             input_vec = np.array(data["vector_72d"])
         elif "dendrites" in data:
-            dendrite_values = list(data["dendrites"].values())
-            input_vec = np.array(dendrite_values)
+            input_vec = np.array(list(data["dendrites"].values()))
         else:
-            input_vec = np.random.randn(72)  # Fallback
+            input_vec = np.random.randn(72)
         
-        # Pad to 256D
-        input_256 = np.zeros(256)
-        input_256[:min(len(input_vec), 256)] = input_vec[:min(len(input_vec), 256)]
+        # Pad to 72D if needed
+        if len(input_vec) < 72:
+            input_vec = np.pad(input_vec, (0, 72 - len(input_vec)))
         
         # Process through CTM
-        result = ctm.process_ticks(input_256, n_ticks=25)
+        n_ticks = data.get("ticks", 25)
+        result = ctm.forward(input_vec[:72], n_ticks)
         
-        # Detect anomalies (low certainty regions)
+        # Detect anomalies (low certainty)
         anomalies = []
-        if result["final_certainty"] < 0.5:
-            anomalies.append("Low overall certainty")
+        if result["certainty"] < 0.5:
+            anomalies.append("Low overall certainty - consider retraining")
         
         return json.dumps({
             "status": "success",
-            "coherent_features": result["final_sync_matrix"][:16][:16],  # 16x16 subset
-            "certainty": result["final_certainty"],
+            "coherent_features": result["predictions"],
+            "certainty": result["certainty"],
+            "best_tick": result["best_tick"],
             "anomalies": anomalies,
-            "ticks_used": result["ticks_used"]
+            "ticks_used": result["ticks_used"],
+            "model": result["model"]
         }, indent=2)
     except Exception as e:
         return json.dumps({"status": "error", "message": str(e)})
 
+
 def reason_hypergraph(context_json: str) -> str:
     """
-    /reason_hypergraph - Reason about hypergraph, propose edges
-    Input: Node features + existing edges
-    Output: Proposed new edges + certainty
+    /reason_hypergraph - Reason about hypergraph context, propose edges
+    
+    Uses CTM synchronization matrix to find strongly correlated node pairs.
+    These become proposed hyperedges.
     """
     try:
         data = json.loads(context_json)
@@ -217,38 +488,40 @@ def reason_hypergraph(context_json: str) -> str:
         n_ticks = data.get("ticks", 50)
         
         # Flatten node features for CTM input
-        input_vec = node_features.flatten()
+        input_vec = node_features.flatten()[:72]
         
         # Process through CTM with more ticks for reasoning
-        result = ctm.process_ticks(input_vec, n_ticks=n_ticks)
+        result = ctm.forward(input_vec, n_ticks)
         
-        # Extract proposed edges from sync matrix (S_ij > 0.8)
-        sync = np.array(result["best_sync_matrix"])
+        # Extract proposed edges from sync matrix (S_ij > 0.7)
         proposed_edges = []
-        
-        n_nodes = min(len(node_features), sync.shape[0])
-        for i in range(n_nodes):
-            for j in range(i+1, n_nodes):
-                sync_ij = sync[i, j]
-                if sync_ij > 0.8:
-                    # Check if edge already exists
-                    edge_exists = any(
-                        (e[0] == i and e[1] == j) or (e[0] == j and e[1] == i)
-                        for e in existing_edges
-                    )
-                    if not edge_exists:
-                        proposed_edges.append([i, j, float(sync_ij)])
+        if result["sync_matrix"] is not None:
+            sync = np.array(result["sync_matrix"])
+            n_nodes = min(len(node_features), sync.shape[0])
+            
+            for i in range(n_nodes):
+                for j in range(i+1, n_nodes):
+                    sync_ij = sync[i, j]
+                    if sync_ij > 0.7:  # Threshold for edge proposal
+                        edge_exists = any(
+                            (e[0] == i and e[1] == j) or (e[0] == j and e[1] == i)
+                            for e in existing_edges
+                        )
+                        if not edge_exists:
+                            proposed_edges.append([i, j, float(sync_ij)])
         
         return json.dumps({
             "status": "success",
             "proposed_edges": proposed_edges,
-            "certainty": result["max_certainty"],
+            "certainty": result["certainty"],
             "best_tick": result["best_tick"],
-            "ticks_used": result["ticks_used"]
+            "ticks_used": result["ticks_used"],
+            "model": result["model"]
         }, indent=2)
     except Exception as e:
         return json.dumps({"status": "error", "message": str(e)})
 
+
 def validate_physics_endpoint(physics_json: str) -> str:
     """
     /validate_physics - Validate trajectory against 5 physics losses
@@ -265,135 +538,238 @@ def validate_physics_endpoint(physics_json: str) -> str:
     except Exception as e:
         return json.dumps({"status": "error", "message": str(e)})
 
+
 def dream_endpoint(dream_json: str) -> str:
     """
-    /dream - Offline consolidation with T=500+ ticks
-    Input: Hypergraph snapshot
-    Output: Discovered patterns + new edges
+    /dream - Offline consolidation with many ticks
+    
+    Discovers patterns, proposes new edges, identifies edges to prune.
     """
     try:
         data = json.loads(dream_json)
         
         snapshot = data.get("hypergraph_snapshot", {})
-        n_ticks = data.get("ticks", 500)
+        n_ticks = min(data.get("ticks", 100), 100)  # Cap at 100 for CPU
         
         # Extract features from snapshot
         nodes = snapshot.get("nodes", [])
         if nodes:
-            input_vec = np.array([n.get("features", [0]*16) for n in nodes]).flatten()
+            input_vec = np.array([n.get("features", [0]*16) for n in nodes]).flatten()[:72]
         else:
-            input_vec = np.random.randn(256)  # Random dream if no nodes
-        
-        # Dream: run CTM with many ticks and no external input after initial
-        result = ctm.process_ticks(input_vec, n_ticks=min(n_ticks, 100))  # Cap at 100 for CPU
+            input_vec = np.random.randn(72)
         
-        # Analyze sync evolution to find patterns
-        sync = np.array(result["final_sync_matrix"])
+        # Dream: run CTM with many ticks
+        result = ctm.forward(input_vec, n_ticks)
         
-        # Find strong sync pairs (new edges)
+        # Analyze sync for patterns
         new_edges = []
-        n = min(len(nodes), sync.shape[0]) if nodes else 16
-        for i in range(n):
-            for j in range(i+1, n):
-                if sync[i, j] > 0.85:
-                    new_edges.append([i, j, float(sync[i, j])])
-        
-        # Find weak sync pairs (edges to prune)
         pruned_edges = []
-        for i in range(n):
-            for j in range(i+1, n):
-                if sync[i, j] < 0.1:
-                    pruned_edges.append([i, j])
+        
+        if result["sync_matrix"] is not None:
+            sync = np.array(result["sync_matrix"])
+            n = min(len(nodes), sync.shape[0]) if nodes else 16
+            
+            for i in range(n):
+                for j in range(i+1, n):
+                    if sync[i, j] > 0.85:
+                        new_edges.append([i, j, float(sync[i, j])])
+                    elif sync[i, j] < 0.1:
+                        pruned_edges.append([i, j])
         
         return json.dumps({
             "status": "success",
             "discovered_patterns": len(new_edges),
-            "new_edges": new_edges[:10],  # Top 10
-            "pruned_edges": pruned_edges[:10],  # Top 10
-            "consolidation_certainty": result["max_certainty"],
-            "ticks_used": result["ticks_used"]
+            "new_edges": new_edges[:10],
+            "pruned_edges": pruned_edges[:10],
+            "consolidation_certainty": result["certainty"],
+            "ticks_used": result["ticks_used"],
+            "model": result["model"]
         }, indent=2)
     except Exception as e:
         return json.dumps({"status": "error", "message": str(e)})
 
+
 def calibrate_stdp_endpoint(stdp_json: str) -> str:
     """
-    /calibrate_stdp - Suggest STDP weight adjustments from sync
+    /calibrate_stdp - Suggest STDP weight adjustments
+    
+    This is the CORE regulatory function:
+    - Receives current 16 dendrite weights
+    - Processes through CTM to get sync patterns
+    - Returns suggested weight adjustments
     """
     try:
         data = json.loads(stdp_json)
         
         current_weights = np.array(data.get("current_weights", [1.0]*16))
-        node_features = np.array(data.get("node_features", [[0]*16]*8))
+        node_features = np.array(data.get("node_features", [[0]*16]*4))
         
-        # Process to get sync matrix
-        input_vec = node_features.flatten()
-        result = ctm.process_ticks(input_vec, n_ticks=25)
+        # Flatten features for CTM input
+        input_vec = node_features.flatten()[:72]
         
-        sync = np.array(result["final_sync_matrix"])
+        # Process through CTM
+        result = ctm.forward(input_vec, n_ticks=25)
+        
+        # Use predictions as weight adjustments
+        predictions = np.array(result["best_predictions"])
         
-        # Suggest weight adjustments based on sync patterns
-        # Uses diagonal of sync (self-similarity) to scale weights
-        suggested = np.zeros(16)
-        for i in range(16):
-            # Average sync of neuron i with others
-            avg_sync = np.mean(sync[i, :])
-            # Scale current weight by sync
-            suggested[i] = current_weights[i] * (0.5 + avg_sync)
+        # Scale based on certainty
+        confidence = result["certainty"]
+        weight_changes = (predictions - 0.5) * confidence * 0.1
+        
+        new_weights = current_weights + weight_changes
         
         return json.dumps({
             "status": "success",
-            "suggested_weights": suggested.tolist(),
-            "weight_changes": (suggested - current_weights).tolist(),
-            "confidence": result["final_certainty"]
+            "suggested_weights": new_weights.tolist(),
+            "weight_changes": weight_changes.tolist(),
+            "confidence": confidence,
+            "best_tick": result["best_tick"],
+            "model": result["model"]
         }, indent=2)
     except Exception as e:
         return json.dumps({"status": "error", "message": str(e)})
 
+
+def regulate_endpoint(regulate_json: str) -> str:
+    """
+    /regulate - Full feedback loop for ART-17 regulation (NEW)
+    
+    Combines all signals to provide comprehensive regulation:
+    - Dendrite state
+    - Latent representation
+    - Physics loss
+    - Anomaly score
+    
+    Returns action recommendation with confidence.
+    """
+    try:
+        data = json.loads(regulate_json)
+        
+        # Inputs from local system
+        dendrites = np.array(data.get("dendrites", [0.0]*16))
+        latent_256 = np.array(data.get("latent_256", [0.0]*256))
+        physics_loss = data.get("physics_loss", 0.0)
+        anomaly_score = data.get("anomaly_score", 0.0)
+        
+        # Combine into 72D input
+        input_72 = np.concatenate([
+            dendrites,           # 16D
+            latent_256[:56]      # 56D from latent
+        ])
+        
+        # Process through CTM
+        result = ctm.forward(input_72, n_ticks=50)
+        
+        # Compute regulation signals
+        predictions = np.array(result["best_predictions"])
+        certainty = result["certainty"]
+        
+        # Urgency based on physics and anomaly
+        urgency = min(1.0, physics_loss + anomaly_score)
+        regulation_strength = urgency * certainty
+        
+        # Weight adjustments
+        dendrite_deltas = predictions * regulation_strength * 0.05
+        
+        # Determine if intervention needed
+        needs_intervention = urgency > 0.5 or certainty < 0.3
+        
+        return json.dumps({
+            "status": "success",
+            "dendrite_deltas": dendrite_deltas.tolist(),
+            "regulation_strength": float(regulation_strength),
+            "confidence": certainty,
+            "urgency": float(urgency),
+            "needs_intervention": needs_intervention,
+            "recommended_action": "ADJUST" if needs_intervention else "MAINTAIN",
+            "best_tick": result["best_tick"],
+            "model": result["model"]
+        }, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)})
+
+
+def train_online_endpoint(train_json: str) -> str:
+    """
+    /train_online - Progressive online training (NEW)
+    
+    Allows the local system to train the CTM with experience.
+    Sends input-output pairs and receives training feedback.
+    """
+    try:
+        data = json.loads(train_json)
+        
+        input_72d = np.array(data.get("input_72d", [0.0]*72))
+        target_16d = np.array(data.get("target_16d", [0.0]*16))
+        physics_loss = data.get("physics_loss", 0.0)
+        
+        # Perform training step
+        result = ctm.train_step(input_72d, target_16d, physics_loss)
+        
+        return json.dumps({
+            "status": result["status"],
+            "loss": result.get("loss"),
+            "mse_loss": result.get("mse_loss"),
+            "physics_penalty": result.get("physics_penalty"),
+            "best_tick": result.get("best_tick"),
+            "forward_count": ctm.forward_count,
+            "message": "Training step completed" if result["status"] == "trained" else result.get("reason")
+        }, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)})
+
+
 def health_check() -> str:
-    """Health check for the CTM server"""
+    """Health check with model info."""
     return json.dumps({
         "status": "healthy",
-        "model": "CTM Nervous System v1.0",
-        "d_model": ctm.d_model,
-        "memory_length": ctm.memory_length,
-        "default_ticks": ctm.n_ticks,
+        "model": f"CTM Nervous System v2.0 ({'Full PyTorch' if ctm.is_full else 'NumPy Fallback'})",
+        "device": DEVICE,
+        "d_model": CONFIG["d_model"],
+        "iterations": CONFIG["iterations"],
+        "memory_length": CONFIG["memory_length"],
+        "forward_count": ctm.forward_count,
         "endpoints": [
             "/sense_snn",
-            "/reason_hypergraph", 
+            "/reason_hypergraph",
             "/validate_physics",
             "/dream",
-            "/calibrate_stdp"
+            "/calibrate_stdp",
+            "/regulate",        # NEW
+            "/train_online"     # NEW
         ]
     }, indent=2)
 
+
 # ============================================================================
 # GRADIO INTERFACE
 # ============================================================================
 
-with gr.Blocks(title="CTM Nervous System") as demo:
+with gr.Blocks(title="CTM Nervous System v2.0", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🧬 CTM Nervous System
-    **Continuous Thought Machine for Hypergraph Maintenance**
+    # 🧬 CTM Nervous System v2.0
+    **Continuous Thought Machine for ART-17 Hypergraph Coherence**
     
     Based on [arXiv:2505.05522](https://arxiv.org/abs/2505.05522) - Sakana AI
     
     ---
     
-    ## Endpoints
-    - **/sense_snn**: Process 72D SNN input
-    - **/reason_hypergraph**: Reason about context, propose edges
-    - **/validate_physics**: Validate against 5 physics losses
-    - **/dream**: Offline consolidation (T=500+)
-    - **/calibrate_stdp**: Suggest STDP weight adjustments
+    ## Key Innovations
+    - **NLMs (Neuron-Level Models)**: Each neuron processes its own history
+    - **Neural Synchronization**: Representation via S = Z·Z^T
+    - **Adaptive Compute**: Halts when confident
+    - **Online Training**: Progressive learning with use
+    
+    ---
     """)
     
     with gr.Tabs():
         with gr.Tab("🔌 /sense_snn"):
-            gr.Markdown("Process 72D SNN input vector")
+            gr.Markdown("Process 72D SNN input through CTM")
             snn_input = gr.Textbox(
                 label="SNN JSON Input",
-                value='{"dendrites": {"d1": 0.1, "d2": 0.2, "d3": 0.3}}',
+                value='{"dendrites": {"d1": 0.1, "d2": 0.2, "d3": 0.3}, "ticks": 25}',
                 lines=5
             )
             snn_output = gr.Textbox(label="Output", lines=10)
@@ -401,7 +777,7 @@ with gr.Blocks(title="CTM Nervous System") as demo:
             snn_btn.click(sense_snn, inputs=snn_input, outputs=snn_output, api_name="sense_snn")
         
         with gr.Tab("🧠 /reason_hypergraph"):
-            gr.Markdown("Reason about hypergraph context")
+            gr.Markdown("Reason about hypergraph context, propose edges")
             reason_input = gr.Textbox(
                 label="Context JSON",
                 value='{"node_features": [[0.1, 0.2], [0.3, 0.4]], "existing_edges": [], "ticks": 50}',
@@ -412,7 +788,7 @@ with gr.Blocks(title="CTM Nervous System") as demo:
             reason_btn.click(reason_hypergraph, inputs=reason_input, outputs=reason_output, api_name="reason_hypergraph")
         
         with gr.Tab("⚡ /validate_physics"):
-            gr.Markdown("Validate against 5 physics losses")
+            gr.Markdown("Validate trajectory against 5 physics losses")
             physics_input = gr.Textbox(
                 label="Physics JSON",
                 value='{"trajectory": [0.1, 0.2, 0.3], "physics_params": {"P_max": 1000}}',
@@ -423,7 +799,7 @@ with gr.Blocks(title="CTM Nervous System") as demo:
             physics_btn.click(validate_physics_endpoint, inputs=physics_input, outputs=physics_output, api_name="validate_physics")
         
         with gr.Tab("💤 /dream"):
-            gr.Markdown("Offline consolidation")
+            gr.Markdown("Offline consolidation - discover patterns")
             dream_input = gr.Textbox(
                 label="Dream JSON",
                 value='{"hypergraph_snapshot": {"nodes": []}, "ticks": 100}',
@@ -434,7 +810,7 @@ with gr.Blocks(title="CTM Nervous System") as demo:
             dream_btn.click(dream_endpoint, inputs=dream_input, outputs=dream_output, api_name="dream")
         
         with gr.Tab("🔧 /calibrate_stdp"):
-            gr.Markdown("Calibrate STDP weights")
+            gr.Markdown("Calibrate STDP weights (Core regulatory function)")
             stdp_input = gr.Textbox(
                 label="STDP JSON",
                 value='{"current_weights": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1], "node_features": [[0.1, 0.2]]}',
@@ -444,16 +820,40 @@ with gr.Blocks(title="CTM Nervous System") as demo:
             stdp_btn = gr.Button("Calibrate", variant="primary")
             stdp_btn.click(calibrate_stdp_endpoint, inputs=stdp_input, outputs=stdp_output, api_name="calibrate_stdp")
         
+        with gr.Tab("🎯 /regulate [NEW]"):
+            gr.Markdown("Full feedback loop for ART-17 regulation")
+            regulate_input = gr.Textbox(
+                label="Regulate JSON",
+                value='{"dendrites": [0.5]*16, "latent_256": [0.1]*256, "physics_loss": 0.01, "anomaly_score": 0.05}',
+                lines=5
+            )
+            regulate_output = gr.Textbox(label="Output", lines=10)
+            regulate_btn = gr.Button("Regulate", variant="primary")
+            regulate_btn.click(regulate_endpoint, inputs=regulate_input, outputs=regulate_output, api_name="regulate")
+        
+        with gr.Tab("📚 /train_online [NEW]"):
+            gr.Markdown("Progressive online training with experience")
+            train_input = gr.Textbox(
+                label="Training JSON",
+                value='{"input_72d": [0.1]*72, "target_16d": [0.5]*16, "physics_loss": 0.01}',
+                lines=5
+            )
+            train_output = gr.Textbox(label="Output", lines=10)
+            train_btn = gr.Button("Train Step", variant="primary")
+            train_btn.click(train_online_endpoint, inputs=train_input, outputs=train_output, api_name="train_online")
+        
         with gr.Tab("❤️ Health"):
-            health_output = gr.Textbox(label="Health Status", lines=10)
+            health_output = gr.Textbox(label="Health Status", lines=15)
             health_btn = gr.Button("Check Health", variant="secondary")
             health_btn.click(health_check, inputs=None, outputs=health_output, api_name="health_check")
     
     gr.Markdown("""
     ---
-    **Architecture**: CTM as Nervous System → Hypergraph as Thought
+    **Architecture**: CTM as Nervous System → Hypergraph as Coherent Thought
+    
+    **Integration**: Local ART-17 ↔ CTM (regulation) ↔ Brain Server (semantics)
     
-    **Training**: Min-Loss + Max-Certainty + Physics Regularization
+    **Training**: Progressive online learning + Physics-Informed Loss
     """)
 
 if __name__ == "__main__":
@@ -461,4 +861,4 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=7860,
         show_error=True
-    )
+    )

app_v1_backup.py

@@ -0,0 +1,464 @@
+"""
+CTM Nervous System Server - Continuous Thought Machine for Hypergraph Maintenance
+===================================================================================
+Implementation of the definitive proposal: CTM as Nervous System for ART-17 Hypergraph.
+
+Endpoints:
+- /sense_snn: Process 72D SNN input with NLM-style processing
+- /reason_hypergraph: Reason about hypergraph context, propose edges
+- /validate_physics: Validate proposals against 5 physics losses
+- /dream: Offline consolidation with T=500+ ticks
+- /calibrate_stdp: Suggest STDP weight adjustments from sync matrix
+- /health: Health check endpoint
+
+Based on: arXiv:2505.05522 (Continuous Thought Machines - Sakana AI)
+"""
+
+import gradio as gr
+import numpy as np
+import json
+from typing import List, Dict, Any, Optional
+import os
+
+# ============================================================================
+# SIMPLIFIED CTM SIMULATION (CPU-only for Hugging Face free tier)
+# ============================================================================
+
+class SimplifiedCTM:
+    """
+    Simplified CTM for CPU-only environment.
+    Simulates the key mechanisms without full PyTorch model.
+    """
+    
+    def __init__(self, d_model: int = 256, memory_length: int = 16, n_ticks: int = 50):
+        self.d_model = d_model
+        self.memory_length = memory_length
+        self.n_ticks = n_ticks
+        
+        # Initialize state
+        self.state_trace = np.zeros((d_model, memory_length))
+        self.activated_state = np.random.randn(d_model) * 0.1
+        
+        # NLM weights (simplified: one weight matrix per "neuron group")
+        self.nlm_weights = np.random.randn(16, memory_length) * 0.1  # 16 groups for 16 dendrites
+        
+    def compute_sync_matrix(self, z: np.ndarray) -> np.ndarray:
+        """S^t = Z · Z^T (normalized)"""
+        z_norm = z / (np.linalg.norm(z) + 1e-8)
+        S = np.outer(z_norm, z_norm)
+        return S
+    
+    def compute_certainty(self, predictions: np.ndarray) -> float:
+        """Certainty = 1 - normalized entropy"""
+        probs = np.abs(predictions) / (np.sum(np.abs(predictions)) + 1e-8)
+        probs = np.clip(probs, 1e-10, 1.0)
+        entropy = -np.sum(probs * np.log(probs))
+        max_entropy = np.log(len(probs))
+        normalized_entropy = entropy / (max_entropy + 1e-8)
+        return float(1.0 - normalized_entropy)
+    
+    def process_ticks(self, input_features: np.ndarray, n_ticks: Optional[int] = None) -> Dict:
+        """Run T internal ticks and return sync matrix + certainty"""
+        n_ticks = n_ticks or self.n_ticks
+        
+        # Ensure input is right size
+        if len(input_features) < self.d_model:
+            input_features = np.pad(input_features, (0, self.d_model - len(input_features)))
+        else:
+            input_features = input_features[:self.d_model]
+        
+        certainties = []
+        sync_matrices = []
+        
+        for t in range(n_ticks):
+            # Simulate synapse update
+            combined = np.concatenate([self.activated_state, input_features[:self.d_model//2]])
+            pre_activation = np.tanh(combined[:self.d_model] * 0.1 + np.random.randn(self.d_model) * 0.01)
+            
+            # Update trace
+            self.state_trace = np.roll(self.state_trace, -1, axis=1)
+            self.state_trace[:, -1] = pre_activation
+            
+            # Simulate NLM (simplified)
+            post_activation = np.zeros(self.d_model)
+            group_size = self.d_model // 16
+            for g in range(16):
+                start = g * group_size
+                end = start + group_size
+                group_trace = self.state_trace[start:end, :]
+                group_output = np.mean(group_trace @ self.nlm_weights[g])
+                post_activation[start:end] = np.tanh(group_output)
+            
+            self.activated_state = post_activation
+            
+            # Compute sync and certainty
+            sync = self.compute_sync_matrix(self.activated_state)
+            cert = self.compute_certainty(self.activated_state)
+            
+            sync_matrices.append(sync)
+            certainties.append(cert)
+        
+        # Find best ticks (min-loss proxy: max certainty)
+        best_tick = int(np.argmax(certainties))
+        
+        return {
+            "final_sync_matrix": sync_matrices[-1].tolist(),
+            "best_sync_matrix": sync_matrices[best_tick].tolist(),
+            "certainties": certainties,
+            "final_certainty": float(certainties[-1]),
+            "max_certainty": float(max(certainties)),
+            "best_tick": best_tick,
+            "ticks_used": n_ticks
+        }
+
+# Global CTM instance
+ctm = SimplifiedCTM(d_model=256, memory_length=16, n_ticks=50)
+
+# ============================================================================
+# PHYSICS VALIDATION (from SNN Omega-21)
+# ============================================================================
+
+def validate_physics(trajectory: List[float], params: Dict) -> Dict:
+    """Validate against 5 physics losses from SNN Omega-21"""
+    trajectory = np.array(trajectory)
+    
+    # L_energy: Energy conservation
+    energy = np.sum(trajectory ** 2)
+    P_max = params.get("P_max", 1000.0)
+    L_energy = float(max(0, energy - P_max) ** 2)
+    
+    # L_thermo: Thermodynamics (dew point check)
+    T_dew = params.get("T_dew", 15.0)
+    T_amb = params.get("T_amb", 25.0)
+    L_thermo = float(max(0, T_dew - T_amb) ** 2)
+    
+    # L_causal: Causality (velocity limit)
+    velocity = np.diff(trajectory) if len(trajectory) > 1 else np.array([0])
+    v_max = params.get("v_max", 100.0)
+    L_causal = float(np.sum(np.maximum(0, np.abs(velocity) - v_max) ** 2))
+    
+    # L_conserv: Flux conservation
+    flux_in = params.get("flux_in", 1.0)
+    flux_out = params.get("flux_out", 1.0)
+    L_conserv = float((flux_in - flux_out) ** 2)
+    
+    # L_entropy: 2nd Law (entropy must increase)
+    entropy_change = params.get("entropy_change", 0.1)
+    L_entropy = float(max(0, -entropy_change) ** 2)
+    
+    # Total physics loss
+    L_total = L_energy + L_thermo + L_causal + L_conserv + L_entropy
+    
+    return {
+        "valid": L_total < 0.01,
+        "L_energy": L_energy,
+        "L_thermo": L_thermo,
+        "L_causal": L_causal,
+        "L_conserv": L_conserv,
+        "L_entropy": L_entropy,
+        "L_total": L_total
+    }
+
+# ============================================================================
+# ENDPOINT FUNCTIONS
+# ============================================================================
+
+def sense_snn(snn_json: str) -> str:
+    """
+    /sense_snn - Process 72D SNN input
+    Input: JSON with dendrite values
+    Output: Coherent features + anomalies
+    """
+    try:
+        data = json.loads(snn_json)
+        
+        # Extract 72D vector (or create from dendrites)
+        if "vector_72d" in data:
+            input_vec = np.array(data["vector_72d"])
+        elif "dendrites" in data:
+            dendrite_values = list(data["dendrites"].values())
+            input_vec = np.array(dendrite_values)
+        else:
+            input_vec = np.random.randn(72)  # Fallback
+        
+        # Pad to 256D
+        input_256 = np.zeros(256)
+        input_256[:min(len(input_vec), 256)] = input_vec[:min(len(input_vec), 256)]
+        
+        # Process through CTM
+        result = ctm.process_ticks(input_256, n_ticks=25)
+        
+        # Detect anomalies (low certainty regions)
+        anomalies = []
+        if result["final_certainty"] < 0.5:
+            anomalies.append("Low overall certainty")
+        
+        return json.dumps({
+            "status": "success",
+            "coherent_features": result["final_sync_matrix"][:16][:16],  # 16x16 subset
+            "certainty": result["final_certainty"],
+            "anomalies": anomalies,
+            "ticks_used": result["ticks_used"]
+        }, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)})
+
+def reason_hypergraph(context_json: str) -> str:
+    """
+    /reason_hypergraph - Reason about hypergraph, propose edges
+    Input: Node features + existing edges
+    Output: Proposed new edges + certainty
+    """
+    try:
+        data = json.loads(context_json)
+        
+        node_features = np.array(data.get("node_features", [[0]*16]*8))
+        existing_edges = data.get("existing_edges", [])
+        n_ticks = data.get("ticks", 50)
+        
+        # Flatten node features for CTM input
+        input_vec = node_features.flatten()
+        
+        # Process through CTM with more ticks for reasoning
+        result = ctm.process_ticks(input_vec, n_ticks=n_ticks)
+        
+        # Extract proposed edges from sync matrix (S_ij > 0.8)
+        sync = np.array(result["best_sync_matrix"])
+        proposed_edges = []
+        
+        n_nodes = min(len(node_features), sync.shape[0])
+        for i in range(n_nodes):
+            for j in range(i+1, n_nodes):
+                sync_ij = sync[i, j]
+                if sync_ij > 0.8:
+                    # Check if edge already exists
+                    edge_exists = any(
+                        (e[0] == i and e[1] == j) or (e[0] == j and e[1] == i)
+                        for e in existing_edges
+                    )
+                    if not edge_exists:
+                        proposed_edges.append([i, j, float(sync_ij)])
+        
+        return json.dumps({
+            "status": "success",
+            "proposed_edges": proposed_edges,
+            "certainty": result["max_certainty"],
+            "best_tick": result["best_tick"],
+            "ticks_used": result["ticks_used"]
+        }, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)})
+
+def validate_physics_endpoint(physics_json: str) -> str:
+    """
+    /validate_physics - Validate trajectory against 5 physics losses
+    """
+    try:
+        data = json.loads(physics_json)
+        trajectory = data.get("trajectory", [0.0])
+        params = data.get("physics_params", {})
+        
+        result = validate_physics(trajectory, params)
+        result["status"] = "success"
+        
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)})
+
+def dream_endpoint(dream_json: str) -> str:
+    """
+    /dream - Offline consolidation with T=500+ ticks
+    Input: Hypergraph snapshot
+    Output: Discovered patterns + new edges
+    """
+    try:
+        data = json.loads(dream_json)
+        
+        snapshot = data.get("hypergraph_snapshot", {})
+        n_ticks = data.get("ticks", 500)
+        
+        # Extract features from snapshot
+        nodes = snapshot.get("nodes", [])
+        if nodes:
+            input_vec = np.array([n.get("features", [0]*16) for n in nodes]).flatten()
+        else:
+            input_vec = np.random.randn(256)  # Random dream if no nodes
+        
+        # Dream: run CTM with many ticks and no external input after initial
+        result = ctm.process_ticks(input_vec, n_ticks=min(n_ticks, 100))  # Cap at 100 for CPU
+        
+        # Analyze sync evolution to find patterns
+        sync = np.array(result["final_sync_matrix"])
+        
+        # Find strong sync pairs (new edges)
+        new_edges = []
+        n = min(len(nodes), sync.shape[0]) if nodes else 16
+        for i in range(n):
+            for j in range(i+1, n):
+                if sync[i, j] > 0.85:
+                    new_edges.append([i, j, float(sync[i, j])])
+        
+        # Find weak sync pairs (edges to prune)
+        pruned_edges = []
+        for i in range(n):
+            for j in range(i+1, n):
+                if sync[i, j] < 0.1:
+                    pruned_edges.append([i, j])
+        
+        return json.dumps({
+            "status": "success",
+            "discovered_patterns": len(new_edges),
+            "new_edges": new_edges[:10],  # Top 10
+            "pruned_edges": pruned_edges[:10],  # Top 10
+            "consolidation_certainty": result["max_certainty"],
+            "ticks_used": result["ticks_used"]
+        }, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)})
+
+def calibrate_stdp_endpoint(stdp_json: str) -> str:
+    """
+    /calibrate_stdp - Suggest STDP weight adjustments from sync
+    """
+    try:
+        data = json.loads(stdp_json)
+        
+        current_weights = np.array(data.get("current_weights", [1.0]*16))
+        node_features = np.array(data.get("node_features", [[0]*16]*8))
+        
+        # Process to get sync matrix
+        input_vec = node_features.flatten()
+        result = ctm.process_ticks(input_vec, n_ticks=25)
+        
+        sync = np.array(result["final_sync_matrix"])
+        
+        # Suggest weight adjustments based on sync patterns
+        # Uses diagonal of sync (self-similarity) to scale weights
+        suggested = np.zeros(16)
+        for i in range(16):
+            # Average sync of neuron i with others
+            avg_sync = np.mean(sync[i, :])
+            # Scale current weight by sync
+            suggested[i] = current_weights[i] * (0.5 + avg_sync)
+        
+        return json.dumps({
+            "status": "success",
+            "suggested_weights": suggested.tolist(),
+            "weight_changes": (suggested - current_weights).tolist(),
+            "confidence": result["final_certainty"]
+        }, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)})
+
+def health_check() -> str:
+    """Health check for the CTM server"""
+    return json.dumps({
+        "status": "healthy",
+        "model": "CTM Nervous System v1.0",
+        "d_model": ctm.d_model,
+        "memory_length": ctm.memory_length,
+        "default_ticks": ctm.n_ticks,
+        "endpoints": [
+            "/sense_snn",
+            "/reason_hypergraph", 
+            "/validate_physics",
+            "/dream",
+            "/calibrate_stdp"
+        ]
+    }, indent=2)
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+with gr.Blocks(title="CTM Nervous System") as demo:
+    gr.Markdown("""
+    # 🧬 CTM Nervous System
+    **Continuous Thought Machine for Hypergraph Maintenance**
+    
+    Based on [arXiv:2505.05522](https://arxiv.org/abs/2505.05522) - Sakana AI
+    
+    ---
+    
+    ## Endpoints
+    - **/sense_snn**: Process 72D SNN input
+    - **/reason_hypergraph**: Reason about context, propose edges
+    - **/validate_physics**: Validate against 5 physics losses
+    - **/dream**: Offline consolidation (T=500+)
+    - **/calibrate_stdp**: Suggest STDP weight adjustments
+    """)
+    
+    with gr.Tabs():
+        with gr.Tab("🔌 /sense_snn"):
+            gr.Markdown("Process 72D SNN input vector")
+            snn_input = gr.Textbox(
+                label="SNN JSON Input",
+                value='{"dendrites": {"d1": 0.1, "d2": 0.2, "d3": 0.3}}',
+                lines=5
+            )
+            snn_output = gr.Textbox(label="Output", lines=10)
+            snn_btn = gr.Button("Process", variant="primary")
+            snn_btn.click(sense_snn, inputs=snn_input, outputs=snn_output, api_name="sense_snn")
+        
+        with gr.Tab("🧠 /reason_hypergraph"):
+            gr.Markdown("Reason about hypergraph context")
+            reason_input = gr.Textbox(
+                label="Context JSON",
+                value='{"node_features": [[0.1, 0.2], [0.3, 0.4]], "existing_edges": [], "ticks": 50}',
+                lines=5
+            )
+            reason_output = gr.Textbox(label="Output", lines=10)
+            reason_btn = gr.Button("Reason", variant="primary")
+            reason_btn.click(reason_hypergraph, inputs=reason_input, outputs=reason_output, api_name="reason_hypergraph")
+        
+        with gr.Tab("⚡ /validate_physics"):
+            gr.Markdown("Validate against 5 physics losses")
+            physics_input = gr.Textbox(
+                label="Physics JSON",
+                value='{"trajectory": [0.1, 0.2, 0.3], "physics_params": {"P_max": 1000}}',
+                lines=5
+            )
+            physics_output = gr.Textbox(label="Output", lines=10)
+            physics_btn = gr.Button("Validate", variant="primary")
+            physics_btn.click(validate_physics_endpoint, inputs=physics_input, outputs=physics_output, api_name="validate_physics")
+        
+        with gr.Tab("💤 /dream"):
+            gr.Markdown("Offline consolidation")
+            dream_input = gr.Textbox(
+                label="Dream JSON",
+                value='{"hypergraph_snapshot": {"nodes": []}, "ticks": 100}',
+                lines=5
+            )
+            dream_output = gr.Textbox(label="Output", lines=10)
+            dream_btn = gr.Button("Dream", variant="primary")
+            dream_btn.click(dream_endpoint, inputs=dream_input, outputs=dream_output, api_name="dream")
+        
+        with gr.Tab("🔧 /calibrate_stdp"):
+            gr.Markdown("Calibrate STDP weights")
+            stdp_input = gr.Textbox(
+                label="STDP JSON",
+                value='{"current_weights": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1], "node_features": [[0.1, 0.2]]}',
+                lines=5
+            )
+            stdp_output = gr.Textbox(label="Output", lines=10)
+            stdp_btn = gr.Button("Calibrate", variant="primary")
+            stdp_btn.click(calibrate_stdp_endpoint, inputs=stdp_input, outputs=stdp_output, api_name="calibrate_stdp")
+        
+        with gr.Tab("❤️ Health"):
+            health_output = gr.Textbox(label="Health Status", lines=10)
+            health_btn = gr.Button("Check Health", variant="secondary")
+            health_btn.click(health_check, inputs=None, outputs=health_output, api_name="health_check")
+    
+    gr.Markdown("""
+    ---
+    **Architecture**: CTM as Nervous System → Hypergraph as Thought
+    
+    **Training**: Min-Loss + Max-Certainty + Physics Regularization
+    """)
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )

requirements.txt

@@ -1,2 +1,21 @@
+# Requirements for CTM Nervous System v2.0 (Full PyTorch)
+# =========================================================
+# Upgraded to use full ContinuousThoughtMachine implementation
+
+# Core Framework
 gradio>=5.0.0
-numpy
+numpy
+
+# PyTorch (CPU-only for HuggingFace free tier)
+# Use torch-cpu to minimize memory footprint
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch>=2.0.0
+
+# For checkpoint saving
+safetensors
+
+# For potential model weights download
+huggingface_hub
+
+# HTTP client for Brain server integration
+requests

requirements_v1.txt

@@ -0,0 +1,2 @@
+gradio>=5.0.0
+numpy

utils/dendrite_losses.py

@@ -0,0 +1,228 @@
+"""
+Dendrite Regulation Loss Function for CTM
+==========================================
+Adapted from Sakana AI CTM losses for ART-17 dendrite regulation task.
+
+This loss combines:
+1. MSE between predicted and target dendrite adjustments
+2. Physics loss penalty (from SNN Omega-21)
+3. Certainty-weighted tick selection (CTM innovation)
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def dendrite_regulation_loss(
+    predictions: torch.Tensor,      # (B, 16, T) - predictions per tick
+    certainties: torch.Tensor,      # (B, 2, T) - [entropy, 1-entropy]
+    targets: torch.Tensor,          # (B, 16) - target deltas
+    physics_loss: torch.Tensor,     # (B,) - from SNN physics validation
+    use_most_certain: bool = True,
+    physics_weight: float = 0.1
+) -> tuple:
+    """
+    CTM Loss adapted for ART-17 dendrite regulation.
+    
+    Combines:
+    1. MSE between prediction and target at min-loss tick
+    2. MSE between prediction and target at max-certainty tick
+    3. Physics loss penalty
+    
+    This dual-tick selection is a key CTM innovation that allows
+    the model to "think" until confident.
+    
+    Args:
+        predictions: Model predictions of shape (B, 16, T)
+            - B: batch size
+            - 16: dendrite dimensions
+            - T: number of internal ticks
+        certainties: Certainty values of shape (B, 2, T)
+            - Second dim: [normalized_entropy, 1-normalized_entropy]
+        targets: Ground truth deltas of shape (B, 16)
+        physics_loss: Physics validation loss of shape (B,)
+        use_most_certain: If True, also consider max-certainty tick
+        physics_weight: Weight for physics loss penalty
+    
+    Returns:
+        total_loss: Combined loss value
+        loss_index: Indices of selected ticks (B,)
+    """
+    B, D, T = predictions.shape  # B, 16, 50
+    
+    # Expand targets to all ticks: (B, 16) -> (B, 16, T)
+    targets_exp = targets.unsqueeze(-1).expand(-1, -1, T)
+    
+    # MSE loss per tick: (B, 16, T) -> (B, T) after mean over dendrites
+    mse_per_tick = F.mse_loss(predictions, targets_exp, reduction='none')
+    mse_per_tick = mse_per_tick.mean(dim=1)  # Average over 16 dendrites
+    
+    # Tick with minimum loss
+    loss_index_1 = mse_per_tick.argmin(dim=1)  # (B,)
+    
+    # Tick with maximum certainty (1 - normalized_entropy)
+    loss_index_2 = certainties[:, 1, :].argmax(dim=1)  # (B,)
+    
+    if not use_most_certain:
+        # Fall back to final tick
+        loss_index_2 = torch.full_like(loss_index_2, T - 1)
+    
+    # Select losses at chosen ticks
+    batch_idx = torch.arange(B, device=predictions.device)
+    loss_min = mse_per_tick[batch_idx, loss_index_1].mean()
+    loss_certain = mse_per_tick[batch_idx, loss_index_2].mean()
+    
+    # Combined MSE loss (average of min-loss and max-certainty)
+    mse_loss = (loss_min + loss_certain) / 2
+    
+    # Physics penalty
+    physics_penalty = physics_loss.mean() * physics_weight
+    
+    # Total loss
+    total_loss = mse_loss + physics_penalty
+    
+    return total_loss, loss_index_2
+
+
+def hypergraph_edge_loss(
+    sync_matrix: torch.Tensor,      # (B, N, N) - synchronization matrix
+    edge_labels: torch.Tensor,      # (B, N, N) - binary edge labels
+    certainties: torch.Tensor,      # (B, 2, T)
+    use_most_certain: bool = True
+) -> tuple:
+    """
+    Loss for predicting hypergraph edges from synchronization matrix.
+    
+    The CTM's sync matrix S = Z·Z^T captures neural synchronization,
+    which we use to predict edges in the hypergraph.
+    
+    Args:
+        sync_matrix: Predicted sync values (B, N, N)
+        edge_labels: Ground truth edges (B, N, N), binary
+        certainties: Certainty values (B, 2, T)
+        use_most_certain: Whether to weight by certainty
+    
+    Returns:
+        loss: BCE loss for edge prediction
+        certainty: Average certainty at best tick
+    """
+    # Binary cross entropy for edge prediction
+    bce_loss = F.binary_cross_entropy_with_logits(
+        sync_matrix, 
+        edge_labels.float(),
+        reduction='mean'
+    )
+    
+    # Weight by certainty if enabled
+    if use_most_certain and certainties is not None:
+        max_certainty = certainties[:, 1, :].max(dim=-1)[0].mean()
+        # Higher certainty -> lower loss weight (model is confident)
+        certainty_weight = 2.0 - max_certainty
+        loss = bce_loss * certainty_weight
+    else:
+        loss = bce_loss
+        max_certainty = torch.tensor(0.5)
+    
+    return loss, max_certainty
+
+
+def combined_art17_loss(
+    predictions: torch.Tensor,
+    certainties: torch.Tensor,
+    sync_matrix: torch.Tensor,
+    dendrite_targets: torch.Tensor,
+    edge_labels: torch.Tensor,
+    physics_loss: torch.Tensor,
+    dendrite_weight: float = 1.0,
+    edge_weight: float = 0.5,
+    physics_weight: float = 0.1
+) -> dict:
+    """
+    Combined loss for ART-17 CTM training.
+    
+    Combines:
+    1. Dendrite regulation loss (primary task)
+    2. Hypergraph edge prediction loss (auxiliary)
+    3. Physics constraint penalty (regularization)
+    
+    Args:
+        predictions: Dendrite predictions (B, 16, T)
+        certainties: Certainty values (B, 2, T)
+        sync_matrix: Sync matrix for edge prediction (B, N, N)
+        dendrite_targets: Target deltas (B, 16)
+        edge_labels: Edge ground truth (B, N, N)
+        physics_loss: Physics validation (B,)
+        dendrite_weight: Weight for dendrite loss
+        edge_weight: Weight for edge loss
+        physics_weight: Weight for physics penalty
+    
+    Returns:
+        Dict with total_loss and component losses
+    """
+    # Dendrite regulation loss
+    dend_loss, best_tick = dendrite_regulation_loss(
+        predictions, certainties, dendrite_targets, 
+        physics_loss, physics_weight=0.0  # Physics handled separately
+    )
+    
+    # Edge prediction loss
+    edge_loss, certainty = hypergraph_edge_loss(
+        sync_matrix, edge_labels, certainties
+    )
+    
+    # Physics penalty
+    phys_penalty = physics_loss.mean() * physics_weight
+    
+    # Total weighted loss
+    total_loss = (
+        dendrite_weight * dend_loss +
+        edge_weight * edge_loss +
+        phys_penalty
+    )
+    
+    return {
+        "total_loss": total_loss,
+        "dendrite_loss": dend_loss,
+        "edge_loss": edge_loss,
+        "physics_penalty": phys_penalty,
+        "best_tick": best_tick,
+        "certainty": certainty
+    }
+
+
+# Keep original loss functions for compatibility
+def compute_ctc_loss(predictions, targets, blank_label=0):
+    """CTC loss for sequence tasks (original from Sakana)."""
+    batch_size, num_classes, prediction_length = predictions.shape
+    _, target_length = targets.shape
+    
+    log_probs = F.log_softmax(predictions, dim=1)
+    log_probs = log_probs.permute(2, 0, 1)
+    
+    input_lengths = torch.full(size=(batch_size,), fill_value=prediction_length, dtype=torch.long)
+    target_lengths = torch.tensor([t.shape[0] for t in targets], dtype=torch.long)
+    
+    ctc_loss = torch.nn.CTCLoss(blank=blank_label, reduction='mean')
+    concatenated_targets = torch.cat(list(targets))
+    loss = ctc_loss(log_probs, concatenated_targets, input_lengths, target_lengths)
+    
+    return loss
+
+
+def image_classification_loss(predictions, certainties, targets, use_most_certain=True):
+    """Image classification loss (original from Sakana)."""
+    targets_expanded = torch.repeat_interleave(targets.unsqueeze(-1), predictions.size(-1), -1)
+    losses = nn.CrossEntropyLoss(reduction='none')(predictions, targets_expanded)
+    
+    loss_index_1 = losses.argmin(dim=1)
+    loss_index_2 = certainties[:,1].argmax(-1)
+    if not use_most_certain:
+        loss_index_2[:] = -1
+    
+    batch_indexer = torch.arange(predictions.size(0), device=predictions.device)
+    loss_minimum_ce = losses[batch_indexer, loss_index_1].mean()
+    loss_selected = losses[batch_indexer, loss_index_2].mean()
+    
+    loss = (loss_minimum_ce + loss_selected)/2
+    return loss, loss_index_2