[Update]: Refined app.py for enhanced GPU processing and memory operation management 🌟

- Added: GPU acceleration to the `process_memory_operation` function for improved performance.
- Updated: Error handling to gracefully fall back to CPU in case of GPU memory issues.
- Improved: Visualization and metrics formatting for better clarity in results.
- Added: New function `generate_art_with_gpu` to streamline artistic generation using GPU.
- Pro Tip of the Commit: When the waves get heavy, let’s keep our GPUs cool and our operations smooth! 🌊❄️
Aye, Aye! 🚢

app.py

@@ -728,107 +728,133 @@ class MemoryWave:
             
         return filepath
 
-    def process_memory_operation(
-        self,
-        operation: str,
-        emotion_valence: float,
-        grid_size: int = DEFAULT_GRID_SIZE,
-        comfort_level: float = 0.8,
-        exploration_depth: float = 0.5,
-        generate_art: bool = True,
-        seed: int = 42
-    ) -> Tuple[str, go.Figure, go.Figure, Optional[np.ndarray]]:
-        """Process a memory operation and return visualizations."""
-        
-        # Ensure we're on GPU if available
-        device_str = get_device()
-        if device_str == "cuda" and self.device != "cuda":
-            self.to("cuda")
-            if pipe is not None and pipe.device.type != "cuda":
-                pipe.to("cuda")
-        
-        try:
-            # Resize grid if needed
-            if grid_size != self.size:
-                self.__init__(size=grid_size, device=self.device)
-            
-            # Process based on operation type
-            if operation == "wave_memory":
-                result = self.generate_wave_memory(emotion_valence)
-                wave_title = "Wave Memory Pattern"
-                wave_data = result["wave"]
-                
-            elif operation == "interference":
-                result = self.generate_interference_pattern(emotion_valence)
-                wave_title = "Interference Pattern"
-                wave_data = result["wave"]
-                
-            elif operation == "resonance":
-                result = self.generate_resonance_pattern(emotion_valence)
-                wave_title = "Resonance Pattern"
-                wave_data = result["wave"]
-                
-            elif operation == "reconstruction":
-                result = self.generate_memory_reconstruction(emotion_valence)
-                wave_title = "Memory Reconstruction"
-                wave_data = result["reconstructed"]
-                
-            elif operation == "hot_tub":
-                result = self.generate_hot_tub_simulation(
-                    emotion_valence, comfort_level, exploration_depth
-                )
-                wave_title = "Hot Tub Exploration"
-                wave_data = result["safe_result"]
-            
-            # Create visualizations
-            wave_plot = self.visualize_wave_pattern(wave_data, wave_title)
-            emotion_plot = self.visualize_emotional_history()
-            
-            # Generate artistic visualization if requested
-            art_output = None
-            if generate_art and STABLE_DIFFUSION_AVAILABLE and pipe is not None:
-                prompt = generate_memory_prompt(operation, emotion_valence)
-                generator = torch.Generator().manual_seed(seed)
-                art_output = pipe(
-                    prompt=prompt,
-                    negative_prompt="text, watermark, signature, blurry, distorted",
-                    guidance_scale=1.5,
-                    num_inference_steps=8,
-                    width=768,
-                    height=768,
-                    generator=generator,
-                ).images[0]
-            
-            # Format metrics for display
-            metrics = result["metrics"]
-            metrics_str = "📊 Analysis Results:\n\n"
-            for key, value in metrics.items():
-                metrics_str += f"• {key.replace('_', ' ').title()}: {value:.4f}\n"
+@spaces.GPU
+def process_memory_operation(
+    memory_wave: MemoryWave,
+    operation: str,
+    emotion_valence: float,
+    grid_size: int = DEFAULT_GRID_SIZE,
+    comfort_level: float = 0.8,
+    exploration_depth: float = 0.5,
+    generate_art: bool = True,
+    seed: int = 42
+) -> Tuple[str, go.Figure, go.Figure, Optional[np.ndarray]]:
+    """Process memory operations with GPU acceleration."""
+    try:
+        # Move to GPU
+        memory_wave.to("cuda")
+        
+        # Resize grid if needed
+        if grid_size != memory_wave.size:
+            memory_wave.__init__(size=grid_size, device="cuda")
+        
+        # Process based on operation type
+        if operation == "wave_memory":
+            result = memory_wave.generate_wave_memory(emotion_valence)
+            wave_title = "Wave Memory Pattern"
+            wave_data = result["wave"]
             
-            metrics_str += f"\n🎭 Emotional Context:\n"
-            metrics_str += f"• Valence: {result['emotion']['valence']:.2f}\n"
-            metrics_str += f"• Arousal: {result['emotion']['arousal']:.2f}\n"
+        elif operation == "interference":
+            result = memory_wave.generate_interference_pattern(emotion_valence)
+            wave_title = "Interference Pattern"
+            wave_data = result["wave"]
             
-            # Save memory snapshot
-            snapshot_path = self.save_memory_snapshot(operation)
-            metrics_str += f"\n💾 Memory snapshot saved: {snapshot_path}"
+        elif operation == "resonance":
+            result = memory_wave.generate_resonance_pattern(emotion_valence)
+            wave_title = "Resonance Pattern"
+            wave_data = result["wave"]
             
-            return metrics_str, wave_plot, emotion_plot, art_output
+        elif operation == "reconstruction":
+            result = memory_wave.generate_memory_reconstruction(emotion_valence)
+            wave_title = "Memory Reconstruction"
+            wave_data = result["reconstructed"]
             
-        except torch.cuda.OutOfMemoryError:
-            print("⚠️ GPU out of memory - falling back to CPU")
-            self.to("cpu")
-            if pipe is not None:
-                pipe.to("cpu")
-            return self.process_memory_operation(
-                operation, emotion_valence, grid_size, 
-                comfort_level, exploration_depth, 
-                generate_art, seed
+        elif operation == "hot_tub":
+            result = memory_wave.generate_hot_tub_simulation(
+                emotion_valence, comfort_level, exploration_depth
             )
-            
-        except Exception as e:
-            print(f"❌ Error during processing: {e}")
-            return None
+            wave_title = "Hot Tub Exploration"
+            wave_data = result["safe_result"]
+        
+        # Create visualizations
+        wave_plot = memory_wave.visualize_wave_pattern(wave_data, wave_title)
+        emotion_plot = memory_wave.visualize_emotional_history()
+        
+        # Generate artistic visualization if requested
+        art_output = None
+        if generate_art and STABLE_DIFFUSION_AVAILABLE and pipe is not None:
+            prompt = generate_memory_prompt(operation, emotion_valence)
+            art_output = generate_art_with_gpu(prompt, seed)
+        
+        # Format metrics for display
+        metrics = result["metrics"]
+        metrics_str = "📊 Analysis Results:\n\n"
+        for key, value in metrics.items():
+            metrics_str += f"• {key.replace('_', ' ').title()}: {value:.4f}\n"
+        
+        metrics_str += f"\n🎭 Emotional Context:\n"
+        metrics_str += f"• Valence: {result['emotion']['valence']:.2f}\n"
+        metrics_str += f"• Arousal: {result['emotion']['arousal']:.2f}\n"
+        
+        # Save memory snapshot
+        snapshot_path = memory_wave.save_memory_snapshot(operation)
+        metrics_str += f"\n💾 Memory snapshot saved: {snapshot_path}"
+        
+        # Move back to CPU
+        memory_wave.to("cpu")
+        
+        return metrics_str, wave_plot, emotion_plot, art_output
+        
+    except torch.cuda.OutOfMemoryError:
+        print("⚠️ GPU out of memory - falling back to CPU")
+        memory_wave.to("cpu")
+        if pipe is not None:
+            pipe.to("cpu")
+        return process_memory_operation(
+            memory_wave, operation, emotion_valence, grid_size, 
+            comfort_level, exploration_depth, generate_art, seed
+        )
+        
+    except Exception as e:
+        print(f"❌ Error during processing: {e}")
+        # Ensure we're back on CPU
+        memory_wave.to("cpu")
+        return None, None, None, None
+
+@spaces.GPU
+def generate_art_with_gpu(prompt: str, seed: int = 42) -> Optional[np.ndarray]:
+    """Generate art using Stable Diffusion with GPU acceleration."""
+    if not STABLE_DIFFUSION_AVAILABLE or pipe is None:
+        return None
+        
+    try:
+        # Move to GPU and optimize
+        pipe.to("cuda")
+        pipe.enable_model_cpu_offload()
+        pipe.enable_vae_slicing()
+        pipe.enable_vae_tiling()
+        pipe.enable_attention_slicing(slice_size="max")
+        
+        # Generate image
+        generator = torch.Generator().manual_seed(seed)
+        image = pipe(
+            prompt=prompt,
+            negative_prompt="text, watermark, signature, blurry, distorted",
+            guidance_scale=1.5,
+            num_inference_steps=8,
+            width=768,
+            height=768,
+            generator=generator,
+        ).images[0]
+        
+        # Move back to CPU
+        pipe.to("cpu")
+        return image
+        
+    except Exception as e:
+        print(f"❌ Error generating art: {e}")
+        pipe.to("cpu")
+        return None
 
 def generate_memory_prompt(operation: str, emotion_valence: float) -> str:
     """Generate an artistic prompt based on the memory operation and emotional context."""
@@ -955,7 +981,7 @@ def create_interface():
         
         # Set up event handlers
         run_btn.click(
-            lambda *args: process_memory_operation(memory_wave, *args),
+            process_memory_operation,  # Use the standalone function
             inputs=[
                 operation_input,
                 emotion_input,