Update optimizer.py

optimizer.py

@@ -30,7 +30,10 @@ class UltraSupremeOptimizer:
         self.usage_count = 0
         self.device = self._get_device()
         self.is_initialized = False
-        # Inicializar modelo inmediatamente en CPU
+        # Forzar float32 en todo PyTorch
+        torch.backends.cuda.matmul.allow_tf32 = False
+        torch.backends.cudnn.allow_tf32 = False
+        # Inicializar modelo inmediatamente en CPU con float32
         self.initialize_model()
 
     @staticmethod
@@ -44,21 +47,31 @@ class UltraSupremeOptimizer:
             return "cpu"
 
     def initialize_model(self) -> bool:
-        """Initialize the CLIP interrogator model - SIN decorador GPU"""
+        """Initialize the CLIP interrogator model - FLOAT32 FORZADO"""
         if self.is_initialized:
             return True
         
         try:
-            # Inicializar en CPU para evitar timeout de GPU
+            # FORZAR FLOAT32 EN TODO - Configuración máxima precisión
             config = Config(
                 clip_model_name="ViT-L-14/openai",
                 download_cache=True,
                 chunk_size=2048,
                 quiet=True,
-                device="cpu"  # Inicializar en CPU primero
+                device="cpu"  # Inicializar en CPU para controlar precisión
             )
             
             self.interrogator = Interrogator(config)
+            
+            # FORZAR FLOAT32 EN TODOS LOS COMPONENTES DEL MODELO
+            if hasattr(self.interrogator, 'clip_model') and self.interrogator.clip_model is not None:
+                self.interrogator.clip_model = self.interrogator.clip_model.float()
+                logger.info("CLIP model forced to float32")
+            
+            if hasattr(self.interrogator, 'blip_model') and self.interrogator.blip_model is not None:
+                self.interrogator.blip_model = self.interrogator.blip_model.float()
+                logger.info("BLIP model forced to float32")
+            
             self.is_initialized = True
             
             # Clean up memory after initialization
@@ -86,8 +99,8 @@ class UltraSupremeOptimizer:
             if image.mode != 'RGB':
                 image = image.convert('RGB')
             
-            # Resize if too large
-            max_size = 768 if self.device != "cpu" else 512
+            # Resize if too large - usar tamaño generoso para máxima calidad
+            max_size = 1024 if self.device != "cpu" else 768
             if image.size[0] > max_size or image.size[1] > max_size:
                 image.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
             
@@ -150,16 +163,23 @@ class UltraSupremeOptimizer:
 
     @spaces.GPU
     def run_clip_inference(self, image: Image.Image) -> Tuple[str, str, str]:
-        """Solo la inferencia CLIP usa GPU - modelo ya inicializado"""
+        """Solo la inferencia CLIP usa GPU - FLOAT32 FORZADO"""
         try:
-            # Mover modelo a GPU solo para inferencia
+            # Mover modelo a GPU MANTENIENDO FLOAT32
             if hasattr(self.interrogator, 'clip_model') and self.device == "cuda":
-                self.interrogator.clip_model = self.interrogator.clip_model.to("cuda")
+                self.interrogator.clip_model = self.interrogator.clip_model.to("cuda").float()
+                logger.info("CLIP model moved to GPU with float32 precision")
+            
+            if hasattr(self.interrogator, 'blip_model') and self.device == "cuda":
+                self.interrogator.blip_model = self.interrogator.blip_model.to("cuda").float()
+                logger.info("BLIP model moved to GPU with float32 precision")
             
-            # Ejecutar inferencias CLIP
-            full_prompt = self.interrogator.interrogate(image)
-            clip_fast = self.interrogator.interrogate_fast(image)
-            clip_classic = self.interrogator.interrogate_classic(image)
+            # FORZAR que las inferencias usen float32
+            with torch.cuda.amp.autocast(enabled=False):  # Deshabilitar autocast para forzar float32
+                # Ejecutar inferencias CLIP en máxima precisión
+                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
             
@@ -170,7 +190,7 @@ class UltraSupremeOptimizer:
     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
+        MÁXIMA PRECISIÓN FLOAT32 EN TODO
         
         Returns:
             Tuple of (prompt, analysis_info, score, breakdown)
@@ -193,10 +213,10 @@ class UltraSupremeOptimizer:
             
             start_time = datetime.now()
             
-            # NUEVO PIPELINE: Usar CLIP Interrogator completo
-            logger.info("ULTRA SUPREME ANALYSIS - Usando pipeline completo de CLIP Interrogator")
+            # PIPELINE CON MÁXIMA PRECISIÓN FLOAT32
+            logger.info("ULTRA SUPREME ANALYSIS - Float32 máxima precisión")
             
-            # Ejecutar inferencia CLIP en GPU (modelo ya inicializado en CPU)
+            # Ejecutar inferencia CLIP en GPU con float32 forzado
             full_prompt, clip_fast, clip_classic = self.run_clip_inference(image)
             
             logger.info(f"Prompt completo de CLIP Interrogator: {full_prompt}")
@@ -295,7 +315,7 @@ class UltraSupremeOptimizer:
                                   duration: float) -> str:
         """Generate detailed analysis report"""
         
-        gpu_status = "⚡ ZeroGPU" if torch.cuda.is_available() else "💻 CPU"
+        gpu_status = "⚡ ZeroGPU (Float32)" if torch.cuda.is_available() else "💻 CPU (Float32)"
         
         # Extraer información clave
         detected_style = analysis.get("detected_style", "general").title()
@@ -303,14 +323,15 @@ class UltraSupremeOptimizer:
         base_prompt_preview = analysis.get("base_prompt", "")[:100] + "..." if len(analysis.get("base_prompt", "")) > 100 else analysis.get("base_prompt", "")
         
         analysis_info = f"""**🚀 ULTRA SUPREME ANALYSIS COMPLETE**
-**Processing:** {gpu_status} • {duration:.1f}s • Full CLIP Interrogator Pipeline  
+**Processing:** {gpu_status} • {duration:.1f}s • Maximum Precision Pipeline  
 **Ultra Score:** {score}/100 • Breakdown: Base({breakdown.get('base_quality',0)}) Technical({breakdown.get('technical_enhancement',0)}) Lighting({breakdown.get('lighting_quality',0)}) Composition({breakdown.get('composition',0)})  
 **Generation:** #{self.usage_count}  
 
 **🧠 INTELLIGENT DETECTION:**
 - **Detected Style:** {detected_style}
 - **Main Subject:** {detected_subject}
-- **Pipeline:** CPU Init → GPU Inference → Flux Optimization
+- **Precision:** Float32 máxima precisión en CPU+GPU
+- **Quality:** Maximum resolution processing (1024px)
 
 **📊 CLIP INTERROGATOR ANALYSIS:**
 - **Base Prompt:** {base_prompt_preview}
@@ -318,13 +339,15 @@ class UltraSupremeOptimizer:
 - **Classic Analysis:** {analysis.get('clip_classic', '')[:80]}...
 
 **⚡ OPTIMIZATION APPLIED:**
-- ✅ Model initialized in CPU (no timeout)
-- ✅ GPU used only for inference
+- ✅ Float32 forzado en todos los modelos
+- ✅ GPU inference con máxima precisión
+- ✅ TensorFloat-32 deshabilitado
+- ✅ Mixed precision deshabilitado
 - ✅ Added professional camera specifications
 - ✅ Enhanced lighting descriptions
 - ✅ Applied Flux-specific optimizations
 - ✅ Removed redundant/generic elements
 
-**🔬 Powered by Pariente AI Research + CLIP Interrogator**"""
+**🔬 Powered by Pariente AI Research + CLIP Interrogator (Float32 Max)**"""
         
         return analysis_info