Update optimizer.py

optimizer.py

@@ -30,6 +30,8 @@ class UltraSupremeOptimizer:
         self.usage_count = 0
         self.device = self._get_device()
         self.is_initialized = False
+        # Inicializar modelo inmediatamente en CPU
+        self.initialize_model()
 
     @staticmethod
     def _get_device() -> str:
@@ -42,27 +44,25 @@ class UltraSupremeOptimizer:
             return "cpu"
 
     def initialize_model(self) -> bool:
-        """Initialize the CLIP interrogator model"""
+        """Initialize the CLIP interrogator model - SIN decorador GPU"""
         if self.is_initialized:
             return True
         
         try:
+            # Inicializar en CPU para evitar timeout de GPU
             config = Config(
                 clip_model_name="ViT-L-14/openai",
                 download_cache=True,
                 chunk_size=2048,
                 quiet=True,
-                device=self.device
+                device="cpu"  # Inicializar en CPU primero
             )
             
             self.interrogator = Interrogator(config)
             self.is_initialized = True
             
             # Clean up memory after initialization
-            if self.device == "cpu":
-                gc.collect()
-            else:
-                torch.cuda.empty_cache()
+            gc.collect()
                 
             return True
             
@@ -149,18 +149,36 @@ class UltraSupremeOptimizer:
         return final_prompt
 
     @spaces.GPU
+    def run_clip_inference(self, image: Image.Image) -> Tuple[str, str, str]:
+        """Solo la inferencia CLIP usa GPU - modelo ya inicializado"""
+        try:
+            # Mover modelo a GPU solo para inferencia
+            if hasattr(self.interrogator, 'clip_model') and self.device == "cuda":
+                self.interrogator.clip_model = self.interrogator.clip_model.to("cuda")
+            
+            # Ejecutar inferencias CLIP
+            full_prompt = self.interrogator.interrogate(image)
+            clip_fast = self.interrogator.interrogate_fast(image)
+            clip_classic = self.interrogator.interrogate_classic(image)
+            
+            return full_prompt, clip_fast, clip_classic
+            
+        except Exception as e:
+            logger.error(f"CLIP inference error: {e}")
+            raise e
+
     def generate_ultra_supreme_prompt(self, image: Any) -> Tuple[str, str, int, Dict[str, int]]:
         """
         Generate ultra supreme prompt from image usando el pipeline completo
+        INICIALIZACIÓN EN CPU, SOLO INFERENCIA EN GPU
         
         Returns:
             Tuple of (prompt, analysis_info, score, breakdown)
         """
         try:
-            # Initialize model if needed
+            # Verificar que el modelo esté inicializado
             if not self.is_initialized:
-                if not self.initialize_model():
-                    return "❌ Model initialization failed.", "Please refresh and try again.", 0, {}
+                return "❌ Model initialization failed.", "Please refresh and try again.", 0, {}
             
             # Validate input
             if image is None:
@@ -178,15 +196,10 @@ class UltraSupremeOptimizer:
             # NUEVO PIPELINE: Usar CLIP Interrogator completo
             logger.info("ULTRA SUPREME ANALYSIS - Usando pipeline completo de CLIP Interrogator")
             
-            # 1. Obtener el prompt COMPLETO de CLIP Interrogator (no solo análisis)
-            # Este incluye descripción + artistas + estilos + mediums
-            full_prompt = self.interrogator.interrogate(image)
-            logger.info(f"Prompt completo de CLIP Interrogator: {full_prompt}")
-            
-            # 2. También obtener los análisis individuales para el reporte
-            clip_fast = self.interrogator.interrogate_fast(image)
-            clip_classic = self.interrogator.interrogate_classic(image)
+            # Ejecutar inferencia CLIP en GPU (modelo ya inicializado en CPU)
+            full_prompt, clip_fast, clip_classic = self.run_clip_inference(image)
             
+            logger.info(f"Prompt completo de CLIP Interrogator: {full_prompt}")
             logger.info(f"Análisis Fast: {clip_fast}")
             logger.info(f"Análisis Classic: {clip_classic}")
             
@@ -217,9 +230,8 @@ class UltraSupremeOptimizer:
             duration = (end_time - start_time).total_seconds()
             
             # Memory cleanup
-            if self.device == "cpu":
-                gc.collect()
-            else:
+            gc.collect()
+            if torch.cuda.is_available():
                 torch.cuda.empty_cache()
             
             # Generate analysis report
@@ -298,7 +310,7 @@ class UltraSupremeOptimizer:
 **🧠 INTELLIGENT DETECTION:**
 - **Detected Style:** {detected_style}
 - **Main Subject:** {detected_subject}
-- **Pipeline:** CLIP Interrogator → Flux Optimization → Technical Enhancement
+- **Pipeline:** CPU Init → GPU Inference → Flux Optimization
 
 **📊 CLIP INTERROGATOR ANALYSIS:**
 - **Base Prompt:** {base_prompt_preview}
@@ -306,7 +318,8 @@ class UltraSupremeOptimizer:
 - **Classic Analysis:** {analysis.get('clip_classic', '')[:80]}...
 
 **⚡ OPTIMIZATION APPLIED:**
-- ✅ Preserved CLIP Interrogator's rich description
+- ✅ Model initialized in CPU (no timeout)
+- ✅ GPU used only for inference
 - ✅ Added professional camera specifications
 - ✅ Enhanced lighting descriptions
 - ✅ Applied Flux-specific optimizations