Update node.py

node.py

@@ -1,54 +1,49 @@
+# cognitive_net/node.py
 import torch
 import torch.nn as nn
+from collections import deque
 from .memory import CognitiveMemory
 
 class CognitiveNode(nn.Module):
-    """Differentiable cognitive node with dynamic plasticity"""
+    """Autonomous neural unit with neuromodulatory dynamics"""
     def __init__(self, node_id: int, input_size: int):
         super().__init__()
         self.id = node_id
         self.input_size = input_size
-        self.activation = 0.0
         
-        # Dynamic input weights with Hebbian plasticity
-        self.weights = nn.Parameter(torch.randn(1))  # Changed from input_size to 1
+        # Adaptive processing components
+        self.weights = nn.Parameter(torch.randn(input_size) * 0.1)
         self.bias = nn.Parameter(torch.zeros(1))
+        self.memory = CognitiveMemory(context_size=input_size)
         
-        # Memory system - adjusted context size
-        self.memory = CognitiveMemory(context_size=1)  # Changed from input_size to 1
-        
-        # Neurotransmitter levels
+        # Neuromodulatory state
         self.dopamine = nn.Parameter(torch.tensor(0.5))
         self.serotonin = nn.Parameter(torch.tensor(0.5))
         
-        # Store recent activations
-        self.recent_activations = {}
-        
+        # Activation history (rolling window)
+        self.recent_activations = deque(maxlen=100)
+
     def forward(self, inputs: torch.Tensor) -> torch.Tensor:
-        # Ensure inputs is a single value tensor
-        inputs = inputs.reshape(1)
-        
-        # Memory influence
+        # Memory integration
         mem_context = self.memory.retrieve(inputs)
-        
-        # Combine inputs with memory context
         combined = inputs * 0.7 + mem_context * 0.3
         
-        # Adaptive activation with neurotransmitter modulation
-        base_activation = torch.tanh(combined * self.weights + self.bias)
-        modulated = base_activation * (1 + self.dopamine - self.serotonin)
+        # Neurotransmitter-modulated activation
+        base_activation = torch.tanh(combined @ self.weights + self.bias)
+        modulated = base_activation * (1 + torch.sigmoid(self.dopamine) 
+                                     - torch.sigmoid(self.serotonin))
         
-        # Update memory
+        # Memory consolidation
         self.memory.add_memory(inputs, modulated.item())
-        
-        # Store recent activation
-        self.recent_activations[len(self.recent_activations)] = modulated.item()
-        if len(self.recent_activations) > 100:
-            self.recent_activations.pop(min(self.recent_activations.keys()))
+        self.recent_activations.append(modulated.item())
         
         return modulated
-    
+
     def update_plasticity(self, reward: float):
-        """Update neurotransmitter levels based on reward signal"""
-        self.dopamine.data = torch.sigmoid(self.dopamine + reward * 0.1)
-        self.serotonin.data = torch.sigmoid(self.serotonin - reward * 0.05)
+        """Adaptive neuromodulation based on performance"""
+        with torch.no_grad():
+            self.dopamine += reward * 0.1
+            self.serotonin -= reward * 0.05
+            # Maintain neurotransmitter bounds
+            self.dopamine.clamp_(0, 1)
+            self.serotonin.clamp_(0, 1)