ok2

app.py

@@ -85,21 +85,13 @@ MEMORY_DIR = "memory_snapshots"
 os.makedirs(MEMORY_DIR, exist_ok=True)
 
 class EmotionalContext:
-    """
-    Implements Mem|8's emotional context structure as described in the paper.
-    
-    Attributes:
-        valence (torch.Tensor): Emotional valence (-128 to 127: negative to positive)
-        arousal (torch.Tensor): Emotional arousal (0 to 255: intensity level)
-        context (torch.Tensor): Contextual flags (16-bit in paper)
-        safety (torch.Tensor): Psychological safety indicator
-    """
+    """Implements Mem|8's emotional context structure."""
     def __init__(self, device_str="cpu"):
         self.device = device_str
-        self.valence = torch.zeros(1, device=device_str)  # -128 to 127: negative to positive
-        self.arousal = torch.zeros(1, device=device_str)  # 0 to 255: intensity level
-        self.context = torch.zeros(1, device=device_str)  # Contextual flags
-        self.safety = torch.ones(1, device=device_str)    # Psychological safety indicator
+        self.valence = torch.zeros(1, device=device_str)
+        self.arousal = torch.zeros(1, device=device_str)
+        self.context = torch.zeros(1, device=device_str)
+        self.safety = torch.ones(1, device=device_str)
         
         # Track emotional history for visualization
         self.history = {
@@ -109,18 +101,28 @@ class EmotionalContext:
         }
     
     def update(self, valence: float, arousal: Optional[float] = None):
-        """Update emotional context with new values and record in history."""
-        self.valence = torch.tensor([valence], device=self.device)
+        """Update emotional context with new values."""
+        # Convert inputs to tensors on the right device
+        if not isinstance(valence, torch.Tensor):
+            valence = torch.tensor([valence], device=self.device)
+        elif valence.device != self.device:
+            valence = valence.to(self.device)
+            
+        self.valence = valence
         
-        # If arousal not provided, calculate based on valence as in the paper
+        # If arousal not provided, calculate based on valence
         if arousal is None:
-            self.arousal = torch.abs(torch.tensor([valence * 2], device=self.device))
+            self.arousal = torch.abs(valence * 2)
         else:
-            self.arousal = torch.tensor([arousal], device=self.device)
-            
-        # Update history
-        self.history['valence'].append(float(self.valence.item()))
-        self.history['arousal'].append(float(self.arousal.item()))
+            if not isinstance(arousal, torch.Tensor):
+                arousal = torch.tensor([arousal], device=self.device)
+            elif arousal.device != self.device:
+                arousal = arousal.to(self.device)
+            self.arousal = arousal
+            
+        # Update history (use CPU values for storage)
+        self.history['valence'].append(float(self.valence.cpu().item()))
+        self.history['arousal'].append(float(self.arousal.cpu().item()))
         self.history['timestamps'].append(time.time())
         
         # Keep history at a reasonable size
@@ -130,34 +132,36 @@ class EmotionalContext:
             self.history['timestamps'] = self.history['timestamps'][-100:]
     
     def get_color_mapping(self) -> Tuple[float, float, float]:
-        """
-        Maps emotional state to RGB color values.
+        """Maps emotional state to RGB color values."""
+        # Get values from tensors (move to CPU for calculations)
+        valence = self.valence.cpu().item()
+        arousal = self.arousal.cpu().item()
         
-        Returns:
-            Tuple[float, float, float]: RGB color values (0-1 range)
-        """
         # Normalize valence to 0-1 range for hue
-        norm_valence = (self.valence.item() - EMOTION_RANGE[0]) / (EMOTION_RANGE[1] - EMOTION_RANGE[0])
+        norm_valence = (valence - EMOTION_RANGE[0]) / (EMOTION_RANGE[1] - EMOTION_RANGE[0])
         
         # Normalize arousal to 0-1 range for saturation
-        norm_arousal = self.arousal.item() / AROUSAL_RANGE[1]
+        norm_arousal = arousal / AROUSAL_RANGE[1]
         
-        # Convert HSV to RGB (hue from valence, saturation from arousal, value=1)
+        # Convert HSV to RGB
         rgb = colorsys.hsv_to_rgb(norm_valence, norm_arousal, 1.0)
         return rgb
     
-    def __str__(self) -> str:
-        """String representation of emotional context."""
-        return f"EmotionalContext(valence={self.valence.item():.2f}, arousal={self.arousal.item():.2f})"
-
     def to(self, device_str):
         """Move the context to a different device."""
+        if self.device == device_str:
+            return self
+            
         self.device = device_str
         self.valence = self.valence.to(device_str)
         self.arousal = self.arousal.to(device_str)
         self.context = self.context.to(device_str)
         self.safety = self.safety.to(device_str)
         return self
+    
+    def __str__(self) -> str:
+        """String representation of emotional context."""
+        return f"EmotionalContext(valence={self.valence.cpu().item():.2f}, arousal={self.arousal.cpu().item():.2f})"
 
 class MemoryWave:
     """
@@ -168,13 +172,13 @@ class MemoryWave:
     """
     def __init__(self, 
                  size: int = DEFAULT_GRID_SIZE, 
-                 device_str: str = "cpu"):  # Use global device
+                 device_str: str = "cpu"):
         """
         Initialize a memory wave system.
         
         Args:
             size: Size of the memory grid (NxN)
-            device_str: Device to use for computations
+            device_str: Device to use for computations (defaults to CPU)
         """
         self.size = size
         self.device = device_str
@@ -192,23 +196,35 @@ class MemoryWave:
         # History of wave states for animation
         self.history = []
         
+    def to(self, device_str):
+        """Move the wave system to a different device."""
+        if self.device == device_str:
+            return self
+            
+        self.device = device_str
+        self.grid = self.grid.to(device_str)
+        self.emotion = self.emotion.to(device_str)
+        self.x = self.x.to(device_str)
+        self.y = self.y.to(device_str)
+        self.X = self.X.to(device_str)
+        self.Y = self.Y.to(device_str)
+        self.memory_types = {k: v.to(device_str) for k, v in self.memory_types.items()}
+        return self
+        
     def create_wave(self, 
                     frequency: float, 
                     amplitude: float, 
                     phase: float = 0.0, 
                     direction: str = "radial") -> torch.Tensor:
-        """
-        Create a wave pattern as described in Mem|8 paper.
-        
-        Args:
-            frequency: Wave frequency (ω in the paper)
-            amplitude: Wave amplitude (A in the paper)
-            phase: Initial phase offset
-            direction: Wave direction pattern ("radial", "linear_x", "linear_y", or "spiral")
+        """Create a wave pattern as described in Mem|8 paper."""
+        # Ensure we're on the right device
+        if not isinstance(frequency, torch.Tensor):
+            frequency = torch.tensor(frequency, device=self.device)
+        if not isinstance(amplitude, torch.Tensor):
+            amplitude = torch.tensor(amplitude, device=self.device)
+        if not isinstance(phase, torch.Tensor):
+            phase = torch.tensor(phase, device=self.device)
             
-        Returns:
-            torch.Tensor: The generated wave pattern
-        """
         if direction == "radial":
             # Radial waves emanating from center (like dropping a stone in water)
             center_x, center_y = self.size/2, self.size/2
@@ -236,15 +252,11 @@ class MemoryWave:
         return wave
     
     def apply_emotional_modulation(self, wave: torch.Tensor) -> torch.Tensor:
-        """
-        Apply emotional modulation to a wave pattern as described in the paper.
-        
-        Args:
-            wave: The input wave pattern
+        """Apply emotional modulation to a wave pattern."""
+        # Ensure wave is on the right device
+        if wave.device != self.device:
+            wave = wave.to(self.device)
             
-        Returns:
-            torch.Tensor: Emotionally modulated wave
-        """
         # Emotional modulation formula from paper: M = A·exp(iωt-kx)·D·E
         # We implement a simplified version where E is based on valence
         valence_factor = self.emotion.valence / 128  # Normalize to -1 to 1 range
@@ -264,17 +276,13 @@ class MemoryWave:
     
     def create_interference(self, wave1: torch.Tensor, wave2: torch.Tensor, 
                            interference_type: str = "constructive") -> torch.Tensor:
-        """
-        Create interference between two memory waves.
-        
-        Args:
-            wave1: First wave pattern
-            wave2: Second wave pattern
-            interference_type: Type of interference ("constructive", "destructive", or "resonance")
+        """Create interference between two memory waves."""
+        # Ensure waves are on the right device
+        if wave1.device != self.device:
+            wave1 = wave1.to(self.device)
+        if wave2.device != self.device:
+            wave2 = wave2.to(self.device)
             
-        Returns:
-            torch.Tensor: The resulting interference pattern
-        """
         if interference_type == "constructive":
             # Simple addition for constructive interference
             return wave1 + wave2
@@ -291,20 +299,13 @@ class MemoryWave:
             raise ValueError(f"Unknown interference type: {interference_type}")
     
     def apply_memory_blanket(self, wave: torch.Tensor, threshold: float = 0.5) -> torch.Tensor:
-        """
-        Apply the memory blanket concept from the paper.
-        
-        The memory blanket acts as an adaptive filter that:
-        1. Catches significant waves (important memories)
-        2. Allows insignificant ripples to fade
-        
-        Args:
-            wave: Input wave pattern
-            threshold: Importance threshold
+        """Apply the memory blanket concept."""
+        # Ensure wave is on the right device
+        if wave.device != self.device:
+            wave = wave.to(self.device)
+        if not isinstance(threshold, torch.Tensor):
+            threshold = torch.tensor(threshold, device=self.device)
             
-        Returns:
-            torch.Tensor: Filtered wave pattern
-        """
         # Calculate wave importance (amplitude)
         importance = torch.abs(wave)
         
@@ -314,21 +315,16 @@ class MemoryWave:
         return filtered_wave
     
     def store_memory(self, wave: torch.Tensor, memory_type: int = 0) -> None:
-        """
-        Store a wave pattern in the specified memory type.
-        
-        Args:
-            wave: Wave pattern to store
-            memory_type: Memory type (0-5) as described in the paper
-        """
-        if memory_type not in self.memory_types:
-            raise ValueError(f"Invalid memory type: {memory_type}")
+        """Store a wave pattern in memory."""
+        # Ensure wave is on the right device
+        if wave.device != self.device:
+            wave = wave.to(self.device)
             
         # Store the wave pattern
         self.memory_types[memory_type] = wave
         
-        # Add to history for animation
-        self.history.append(wave.clone().cpu().numpy())
+        # Add to history for animation (move to CPU for numpy conversion)
+        self.history.append(wave.cpu().numpy())
         
         # Keep history at a reasonable size
         if len(self.history) > 100:
@@ -834,18 +830,6 @@ class MemoryWave:
             print(f"❌ Error during processing: {e}")
             return None
 
-    def to(self, device_str):
-        """Move the wave system to a different device."""
-        self.device = device_str
-        self.grid = self.grid.to(device_str)
-        self.emotion = self.emotion.to(device_str)
-        self.x = self.x.to(device_str)
-        self.y = self.y.to(device_str)
-        self.X = self.X.to(device_str)
-        self.Y = self.Y.to(device_str)
-        self.memory_types = {k: v.to(device_str) for k, v in self.memory_types.items()}
-        return self
-
 def generate_memory_prompt(operation: str, emotion_valence: float) -> str:
     """Generate an artistic prompt based on the memory operation and emotional context."""