Update optimizer.py

optimizer.py

@@ -30,10 +30,7 @@ class UltraSupremeOptimizer:
         self.usage_count = 0
         self.device = self._get_device()
         self.is_initialized = False
-        # 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
+        # Inicializar modelo inmediatamente
         self.initialize_model()
 
     @staticmethod
@@ -47,31 +44,21 @@ class UltraSupremeOptimizer:
             return "cpu"
 
     def initialize_model(self) -> bool:
-        """Initialize the CLIP interrogator model - FLOAT32 FORZADO"""
+        """Initialize the CLIP interrogator model"""
         if self.is_initialized:
             return True
         
         try:
-            # FORZAR FLOAT32 EN TODO - Configuración máxima precisión
+            # Configuración estándar sin forzar precisión
             config = Config(
                 clip_model_name="ViT-L-14/openai",
                 download_cache=True,
                 chunk_size=2048,
                 quiet=True,
-                device="cpu"  # Inicializar en CPU para controlar precisión
+                device="cpu"  # Inicializar en CPU
             )
             
             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
@@ -163,34 +150,54 @@ class UltraSupremeOptimizer:
 
     @spaces.GPU
     def run_clip_inference(self, image: Image.Image) -> Tuple[str, str, str]:
-        """Solo la inferencia CLIP usa GPU - FLOAT32 FORZADO"""
+        """Solo la inferencia CLIP usa GPU"""
         try:
-            # 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").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")
+            # Mover modelos a GPU sin forzar precisión
+            if self.device == "cuda":
+                # Configurar el dispositivo en el interrogator
+                self.interrogator.config.device = "cuda"
+                
+                # Mover modelos a GPU manteniendo su precisión nativa
+                if hasattr(self.interrogator, 'clip_model') and self.interrogator.clip_model is not None:
+                    self.interrogator.clip_model = self.interrogator.clip_model.to("cuda")
+                    logger.info("CLIP model moved to GPU with native precision")
+                
+                if hasattr(self.interrogator, 'blip_model') and self.interrogator.blip_model is not None:
+                    self.interrogator.blip_model = self.interrogator.blip_model.to("cuda")
+                    logger.info("BLIP model moved to GPU with native precision")
             
-            # 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)
+            # Ejecutar inferencias CLIP con precisión nativa
+            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
+            # Si falla en GPU, intentar en CPU
+            if self.device == "cuda":
+                logger.info("Falling back to CPU inference")
+                self.interrogator.config.device = "cpu"
+                
+                if hasattr(self.interrogator, 'clip_model') and self.interrogator.clip_model is not None:
+                    self.interrogator.clip_model = self.interrogator.clip_model.to("cpu")
+                
+                if hasattr(self.interrogator, 'blip_model') and self.interrogator.blip_model is not None:
+                    self.interrogator.blip_model = self.interrogator.blip_model.to("cpu")
+                
+                # Reintentar en CPU
+                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
+            else:
+                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
-        MÁXIMA PRECISIÓN FLOAT32 EN TODO
         
         Returns:
             Tuple of (prompt, analysis_info, score, breakdown)
@@ -213,10 +220,9 @@ class UltraSupremeOptimizer:
             
             start_time = datetime.now()
             
-            # PIPELINE CON MÁXIMA PRECISIÓN FLOAT32
-            logger.info("ULTRA SUPREME ANALYSIS - Float32 máxima precisión")
+            logger.info("ULTRA SUPREME ANALYSIS - Starting pipeline")
             
-            # Ejecutar inferencia CLIP en GPU con float32 forzado
+            # Ejecutar inferencia CLIP en GPU
             full_prompt, clip_fast, clip_classic = self.run_clip_inference(image)
             
             logger.info(f"Prompt completo de CLIP Interrogator: {full_prompt}")
@@ -315,7 +321,8 @@ class UltraSupremeOptimizer:
                                   duration: float) -> str:
         """Generate detailed analysis report"""
         
-        gpu_status = "⚡ ZeroGPU (Float32)" if torch.cuda.is_available() else "💻 CPU (Float32)"
+        gpu_status = "⚡ ZeroGPU" if torch.cuda.is_available() else "💻 CPU"
+        precision_info = "Native Model Precision" if torch.cuda.is_available() else "CPU Processing"
         
         # Extraer información clave
         detected_style = analysis.get("detected_style", "general").title()
@@ -323,14 +330,14 @@ 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 • Maximum Precision Pipeline  
+**Processing:** {gpu_status} • {duration:.1f}s • {precision_info}  
 **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}
-- **Precision:** Float32 máxima precisión en CPU+GPU
+- **Precision:** Using native model precision for optimal performance
 - **Quality:** Maximum resolution processing (1024px)
 
 **📊 CLIP INTERROGATOR ANALYSIS:**
@@ -339,15 +346,14 @@ class UltraSupremeOptimizer:
 - **Classic Analysis:** {analysis.get('clip_classic', '')[:80]}...
 
 **⚡ OPTIMIZATION APPLIED:**
-- ✅ Float32 forzado en todos los modelos
-- ✅ GPU inference con máxima precisión
-- ✅ TensorFloat-32 deshabilitado
-- ✅ Mixed precision deshabilitado
+- ✅ Native precision inference for stability
+- ✅ GPU acceleration when available
+- ✅ Automatic fallback to CPU if needed
 - ✅ Added professional camera specifications
 - ✅ Enhanced lighting descriptions
 - ✅ Applied Flux-specific optimizations
 - ✅ Removed redundant/generic elements
 
-**🔬 Powered by Pariente AI Research + CLIP Interrogator (Float32 Max)**"""
+**🔬 Powered by Pariente AI Research + CLIP Interrogator**"""
         
         return analysis_info