Update analyzer.py

analyzer.py

@@ -1,373 +1,317 @@
 """
-Ultra Supreme Analyzer for image analysis and prompt building
-VERSIÓN MEJORADA - Potencia CLIP en lugar de limitarlo
+Ultra Supreme Optimizer - Main optimization engine for image analysis
+VERSIÓN MEJORADA - Usa el prompt completo de CLIP Interrogator
 """
 
-import re
-from typing import Dict, List, Any, Tuple
+# IMPORTANT: spaces must be imported BEFORE torch or any CUDA-using library
+import spaces
+import gc
 import logging
+from datetime import datetime
+from typing import Tuple, Dict, Any, Optional
+
+import torch
+import numpy as np
+from PIL import Image
+from clip_interrogator import Config, Interrogator
+
+from analyzer import UltraSupremeAnalyzer
 
 logger = logging.getLogger(__name__)
 
 
-class UltraSupremeAnalyzer:
-    """
-    ULTRA SUPREME ANALYSIS ENGINE - POTENCIA CLIP, NO LO LIMITA
-    """
+class UltraSupremeOptimizer:
+    """Main optimizer class for ultra supreme image analysis"""
     
     def __init__(self):
-        # Palabras a limpiar de las descripciones de CLIP
-        self.cleanup_patterns = [
-            r'arafed\s*',
-            r'there is\s*',
-            r'a photo of\s*',
-            r'an image of\s*',
-            r'a picture of\s*',
-            r'inspired by [^,]+,?\s*',
-            r'by [A-Z][^,]+,?\s*',
-            r'trending on [^,]+,?\s*',
-            r'featured on [^,]+,?\s*',
-            r'\d+k\s*',
-            r'::\s*::\s*',
-            r'contest winner,?\s*',
-            r'award winning,?\s*',
-        ]
-        
-        # Indicadores de calidad técnica
-        self.technical_indicators = {
-            'portrait': ['portrait', 'headshot', 'face', 'person', 'man', 'woman', 'child'],
-            'landscape': ['mountain', 'landscape', 'nature', 'outdoor', 'field', 'forest'],
-            'dramatic': ['dramatic', 'light shining', 'silhouette', 'backlit', 'atmospheric'],
-            'professional': ['professional', 'studio', 'formal', 'business'],
-            'artistic': ['artistic', 'creative', 'abstract', 'conceptual'],
-            'documentary': ['documentary', 'candid', 'street', 'journalism', 'authentic']
-        }
-        
-        # Mejoras de iluminación basadas en contexto
-        self.lighting_enhancements = {
-            'outdoor': 'natural lighting with golden hour warmth',
-            'mountain': 'dramatic alpine lighting with atmospheric haze',
-            'portrait': 'professional portrait lighting with subtle rim light',
-            'silhouette': 'dramatic backlighting creating ethereal silhouettes',
-            'indoor': 'soft diffused window lighting with gentle shadows',
-            'night': 'cinematic low-key lighting with strategic highlights',
-            'default': 'masterful lighting that enhances depth and dimension'
-        }
-        
-        # Configuraciones de cámara según el tipo de foto
-        self.camera_configs = {
-            'portrait': 'Shot on Hasselblad X2D 100C, 90mm f/2.5 lens at f/2.8',
-            'landscape': 'Shot on Phase One XT, 40mm f/4 lens at f/8',
-            'dramatic': 'Shot on Canon R5, 85mm f/1.2 lens at f/2',
-            'street': 'Shot on Leica M11, 35mm f/1.4 lens at f/2.8',
-            'default': 'Shot on Phase One XF IQ4, 80mm f/2.8 lens at f/4'
-        }
+        self.interrogator: Optional[Interrogator] = None
+        self.analyzer = UltraSupremeAnalyzer()
+        self.usage_count = 0
+        self.device = self._get_device()
+        self.is_initialized = False
 
-    def clean_clip_description(self, description: str) -> str:
-        """Limpia la descripción de CLIP eliminando ruido pero preservando contenido valioso"""
-        cleaned = description.lower()
-        
-        # Eliminar patrones de ruido
-        for pattern in self.cleanup_patterns:
-            cleaned = re.sub(pattern, '', cleaned, flags=re.IGNORECASE)
-        
-        # Limpiar espacios múltiples y comas redundantes
-        cleaned = re.sub(r'\s+', ' ', cleaned)
-        cleaned = re.sub(r',\s*,+', ',', cleaned)
-        cleaned = re.sub(r'^\s*,\s*', '', cleaned)
-        cleaned = re.sub(r'\s*,\s*$', '', cleaned)
-        
-        return cleaned.strip()
-    
-    def extract_key_elements(self, clip_fast: str, clip_classic: str, clip_best: str) -> Dict[str, Any]:
-        """Extrae elementos clave de las tres descripciones de CLIP"""
-        
-        # Limpiar todas las descripciones
-        fast_clean = self.clean_clip_description(clip_fast)
-        classic_clean = self.clean_clip_description(clip_classic)
-        best_clean = self.clean_clip_description(clip_best)
-        
-        # Combinar información única de las tres fuentes
-        all_descriptions = f"{fast_clean} {classic_clean} {best_clean}"
-        
-        # Extraer elementos principales
-        elements = {
-            'main_subject': self._extract_main_subject(all_descriptions),
-            'action': self._extract_action(all_descriptions),
-            'location': self._extract_location(all_descriptions),
-            'mood': self._extract_mood(all_descriptions),
-            'special_features': self._extract_special_features(all_descriptions),
-            'technical_style': self._determine_technical_style(all_descriptions),
-            'original_essence': self._preserve_unique_elements(fast_clean, classic_clean, best_clean)
-        }
-        
-        return elements
-    
-    def _extract_main_subject(self, description: str) -> str:
-        """Extrae el sujeto principal de la descripción"""
-        # Buscar patrones comunes de sujetos
-        subject_patterns = [
-            r'(a |an )?([\w\s]+ )?(man|woman|person|child|boy|girl|people|group)',
-            r'(a |an )?([\w\s]+ )?(portrait|face|figure)',
-            r'(a |an )?([\w\s]+ )?(landscape|mountain|building|structure)',
-            r'(a |an )?([\w\s]+ )?(animal|dog|cat|bird)',
-        ]
-        
-        for pattern in subject_patterns:
-            match = re.search(pattern, description)
-            if match:
-                return match.group(0).strip()
-        
-        # Si no encuentra un patrón específico, tomar las primeras palabras significativas
-        words = description.split()
-        if len(words) > 2:
-            return ' '.join(words[:3])
-        
-        return "figure"
-    
-    def _extract_action(self, description: str) -> str:
-        """Extrae la acción o pose del sujeto"""
-        action_keywords = ['standing', 'sitting', 'walking', 'running', 'looking', 
-                          'holding', 'wearing', 'posing', 'working', 'playing']
-        
-        for keyword in action_keywords:
-            if keyword in description:
-                # Extraer contexto alrededor de la palabra clave
-                pattern = rf'\b\w*\s*{keyword}\s*\w*\s*\w*'
-                match = re.search(pattern, description)
-                if match:
-                    return match.group(0).strip()
-        
-        return ""
-    
-    def _extract_location(self, description: str) -> str:
-        """Extrae información de ubicación o ambiente"""
-        location_keywords = ['mountain', 'beach', 'forest', 'city', 'street', 'indoor',
-                            'outdoor', 'studio', 'nature', 'urban', 'field', 'desert',
-                            'ocean', 'lake', 'building', 'home', 'office']
-        
-        found_locations = []
-        for keyword in location_keywords:
-            if keyword in description:
-                found_locations.append(keyword)
-        
-        if found_locations:
-            return ' '.join(found_locations[:2])  # Máximo 2 ubicaciones
-        
-        return ""
-    
-    def _extract_mood(self, description: str) -> str:
-        """Extrae el mood o atmósfera de la imagen"""
-        mood_keywords = ['dramatic', 'peaceful', 'serene', 'intense', 'mysterious',
-                        'joyful', 'melancholic', 'powerful', 'ethereal', 'moody',
-                        'bright', 'dark', 'atmospheric', 'dreamy', 'dynamic']
-        
-        for keyword in mood_keywords:
-            if keyword in description:
-                return keyword
-        
-        return ""
-    
-    def _extract_special_features(self, description: str) -> List[str]:
-        """Extrae características especiales únicas de la descripción"""
-        special_patterns = [
-            'light shining on [\w\s]+',
-            'wearing [\w\s]+',
-            'with [\w\s]+ in the background',
-            'surrounded by [\w\s]+',
-            '[\w\s]+ lighting',
-            '[\w\s]+ atmosphere'
-        ]
-        
-        features = []
-        for pattern in special_patterns:
-            matches = re.findall(pattern, description)
-            features.extend(matches)
-        
-        return features[:3]  # Limitar a 3 características especiales
-    
-    def _determine_technical_style(self, description: str) -> str:
-        """Determina el estilo técnico más apropiado basado en el contenido"""
-        style_scores = {}
-        
-        for style, keywords in self.technical_indicators.items():
-            score = sum(1 for keyword in keywords if keyword in description)
-            if score > 0:
-                style_scores[style] = score
-        
-        if style_scores:
-            return max(style_scores, key=style_scores.get)
-        
-        return 'default'
-    
-    def _preserve_unique_elements(self, fast: str, classic: str, best: str) -> str:
-        """Preserva elementos únicos e interesantes de las descripciones"""
-        # Encontrar frases únicas que aparecen en alguna descripción
-        all_words = set(fast.split() + classic.split() + best.split())
-        common_words = set(['a', 'an', 'the', 'is', 'are', 'was', 'were', 'with', 'of', 'in', 'on', 'at'])
-        
-        unique_words = all_words - common_words
-        
-        # Buscar frases interesantes que contengan estas palabras únicas
-        unique_phrases = []
-        for desc in [fast, classic, best]:
-            if 'light shining' in desc or 'adventure gear' in desc or 'anthropological' in desc:
-                # Estas son frases únicas valiosas
-                unique_phrases.append(desc)
-                break
-        
-        return ' '.join(unique_phrases[:1]) if unique_phrases else ""
-    
-    def build_ultra_supreme_prompt(self, elements: Dict[str, Any], original_descriptions: List[str]) -> str:
-        """Construye un prompt que POTENCIA la visión de CLIP"""
-        
-        components = []
-        
-        # 1. Sujeto principal con artículo apropiado
-        subject = elements['main_subject']
-        if subject:
-            # Determinar artículo
-            if subject[0].lower() in 'aeiou':
-                components.append(f"An {subject}")
-            else:
-                components.append(f"A {subject}")
+    @staticmethod
+    def _get_device() -> str:
+        """Determine the best available device for computation"""
+        if torch.cuda.is_available():
+            return "cuda"
+        elif torch.backends.mps.is_available():
+            return "mps"
         else:
-            components.append("A figure")
-        
-        # 2. Acción si existe
-        if elements['action']:
-            components.append(elements['action'])
-        
-        # 3. Características especiales (esto es lo que hace única la imagen)
-        if elements['special_features']:
-            for feature in elements['special_features'][:2]:
-                components.append(feature)
-        
-        # 4. Ubicación/Ambiente
-        if elements['location']:
-            if 'mountain' in elements['location']:
-                components.append("on a majestic mountain peak")
-            elif 'outdoor' in elements['location'] or 'nature' in elements['location']:
-                components.append("in a breathtaking natural setting")
+            return "cpu"
+
+    def initialize_model(self) -> bool:
+        """Initialize the CLIP interrogator model"""
+        if self.is_initialized:
+            return True
+        
+        try:
+            config = Config(
+                clip_model_name="ViT-L-14/openai",
+                download_cache=True,
+                chunk_size=2048,
+                quiet=True,
+                device=self.device
+            )
+            
+            self.interrogator = Interrogator(config)
+            self.is_initialized = True
+            
+            # Clean up memory after initialization
+            if self.device == "cpu":
+                gc.collect()
             else:
-                components.append(f"in {elements['location']}")
-        
-        # 5. Mood/Atmósfera si existe
-        if elements['mood']:
-            components.append(f"capturing a {elements['mood']} atmosphere")
-        
-        # 6. Iluminación basada en contexto
-        lighting_context = elements['location'] or elements['technical_style']
-        lighting = self.lighting_enhancements.get(lighting_context, self.lighting_enhancements['default'])
-        components.append(f"illuminated with {lighting}")
-        
-        # 7. Configuración técnica de cámara
-        camera_setup = self.camera_configs.get(elements['technical_style'], self.camera_configs['default'])
-        components.append(camera_setup)
+                torch.cuda.empty_cache()
+                
+            return True
+            
+        except Exception as e:
+            logger.error(f"Initialization error: {e}")
+            return False
+
+    def optimize_image(self, image: Any) -> Optional[Image.Image]:
+        """Optimize image for processing"""
+        if image is None:
+            return None
+            
+        try:
+            # Convert to PIL Image if necessary
+            if isinstance(image, np.ndarray):
+                image = Image.fromarray(image)
+            elif not isinstance(image, Image.Image):
+                image = Image.open(image)
+            
+            # Convert to RGB if necessary
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Resize if too large
+            max_size = 768 if self.device != "cpu" else 512
+            if image.size[0] > max_size or image.size[1] > max_size:
+                image.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
+            
+            return image
+            
+        except Exception as e:
+            logger.error(f"Image optimization error: {e}")
+            return None
+
+    def apply_flux_rules(self, base_prompt: str) -> str:
+        """Aplica las reglas de Flux a un prompt base de CLIP Interrogator"""
+        
+        # Limpiar el prompt de elementos no deseados
+        cleanup_patterns = [
+            r',\s*trending on artstation',
+            r',\s*trending on [^,]+',
+            r',\s*\d+k\s*',
+            r',\s*\d+k resolution',
+            r',\s*artstation',
+            r',\s*concept art',
+            r',\s*digital art',
+            r',\s*by greg rutkowski',  # Remover artistas genéricos overused
+        ]
         
-        # 8. Estilo fotográfico final
-        if elements['technical_style'] == 'portrait':
-            components.append("masterful portrait photography")
-        elif elements['technical_style'] == 'landscape':
-            components.append("epic landscape photography")
-        elif elements['technical_style'] == 'dramatic':
-            components.append("cinematic photography with powerful visual impact")
-        elif elements['technical_style'] == 'documentary':
-            components.append("authentic documentary photography")
+        cleaned_prompt = base_prompt
+        for pattern in cleanup_patterns:
+            cleaned_prompt = re.sub(pattern, '', cleaned_prompt, flags=re.IGNORECASE)
+        
+        # Detectar el tipo de imagen para añadir configuración de cámara apropiada
+        camera_config = ""
+        if any(word in base_prompt.lower() for word in ['portrait', 'person', 'man', 'woman', 'face']):
+            camera_config = ", Shot on Hasselblad X2D 100C, 90mm f/2.5 lens at f/2.8, professional portrait photography"
+        elif any(word in base_prompt.lower() for word in ['landscape', 'mountain', 'nature', 'outdoor']):
+            camera_config = ", Shot on Phase One XT, 40mm f/4 lens at f/8, epic landscape photography"
+        elif any(word in base_prompt.lower() for word in ['street', 'urban', 'city']):
+            camera_config = ", Shot on Leica M11, 35mm f/1.4 lens at f/2.8, documentary street photography"
         else:
-            components.append("professional photography with exceptional detail")
-        
-        # 9. Añadir esencia única preservada si existe
-        if elements['original_essence'] and len(elements['original_essence']) > 10:
-            # Incluir elementos únicos que CLIP detectó
-            logger.info(f"Preservando esencia única: {elements['original_essence']}")
-        
-        # Construir prompt final
-        prompt = ", ".join(components)
-        
-        # Limpieza final
-        prompt = re.sub(r'\s+', ' ', prompt)
-        prompt = re.sub(r',\s*,+', ',', prompt)
-        prompt = re.sub(r'\s*,\s*', ', ', prompt)
-        
-        # Capitalizar primera letra
-        if prompt:
-            prompt = prompt[0].upper() + prompt[1:]
-        
-        logger.info(f"Prompt generado: {prompt}")
+            camera_config = ", Shot on Phase One XF IQ4, 80mm f/2.8 lens at f/4, professional photography"
+        
+        # Añadir mejoras de iluminación si no están presentes
+        if 'lighting' not in cleaned_prompt.lower():
+            if 'dramatic' in cleaned_prompt.lower():
+                cleaned_prompt += ", dramatic cinematic lighting"
+            elif 'portrait' in cleaned_prompt.lower():
+                cleaned_prompt += ", professional studio lighting with subtle rim light"
+            else:
+                cleaned_prompt += ", masterful natural lighting"
         
-        return prompt
-    
-    def ultra_supreme_analysis(self, clip_fast: str, clip_classic: str, clip_best: str) -> Dict[str, Any]:
-        """Análisis que POTENCIA la información de CLIP en lugar de limitarla"""
+        # Construir el prompt final
+        final_prompt = cleaned_prompt + camera_config
         
-        logger.info("Iniciando análisis MEJORADO que potencia CLIP")
+        # Asegurar que empiece con mayúscula
+        final_prompt = final_prompt[0].upper() + final_prompt[1:] if final_prompt else final_prompt
         
-        # Extraer elementos clave de las descripciones
-        elements = self.extract_key_elements(clip_fast, clip_classic, clip_best)
+        # Limpiar espacios y comas duplicadas
+        final_prompt = re.sub(r'\s+', ' ', final_prompt)
+        final_prompt = re.sub(r',\s*,+', ',', final_prompt)
         
-        # Construir resultado del análisis
-        result = {
-            "elements": elements,
-            "technical_style": elements['technical_style'],
-            "unique_features": elements['special_features'],
-            "preserved_essence": elements['original_essence'],
-            "mood": elements['mood'],
-            "location": elements['location']
+        return final_prompt
+
+    @spaces.GPU
+    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
+        
+        Returns:
+            Tuple of (prompt, analysis_info, score, breakdown)
+        """
+        try:
+            # Initialize model if needed
+            if not self.is_initialized:
+                if not self.initialize_model():
+                    return "❌ Model initialization failed.", "Please refresh and try again.", 0, {}
+            
+            # Validate input
+            if image is None:
+                return "❌ Please upload an image.", "No image provided.", 0, {}
+            
+            self.usage_count += 1
+            
+            # Optimize image
+            image = self.optimize_image(image)
+            if image is None:
+                return "❌ Image processing failed.", "Invalid image format.", 0, {}
+            
+            start_time = datetime.now()
+            
+            # 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)
+            
+            logger.info(f"Análisis Fast: {clip_fast}")
+            logger.info(f"Análisis Classic: {clip_classic}")
+            
+            # 3. Aplicar reglas de Flux al prompt completo
+            import re
+            optimized_prompt = self.apply_flux_rules(full_prompt)
+            
+            # 4. Crear análisis para el reporte (simplificado)
+            analysis_summary = {
+                "base_prompt": full_prompt,
+                "clip_fast": clip_fast,
+                "clip_classic": clip_classic,
+                "optimized": optimized_prompt,
+                "detected_style": self._detect_style(full_prompt),
+                "detected_subject": self._detect_subject(full_prompt)
+            }
+            
+            # 5. Calcular score basado en la riqueza del prompt
+            score = self._calculate_score(optimized_prompt, full_prompt)
+            breakdown = {
+                "base_quality": min(len(full_prompt) // 10, 25),
+                "technical_enhancement": 25 if "Shot on" in optimized_prompt else 0,
+                "lighting_quality": 25 if "lighting" in optimized_prompt.lower() else 0,
+                "composition": 25 if any(word in optimized_prompt.lower() for word in ["professional", "masterful", "epic"]) else 0
+            }
+            score = sum(breakdown.values())
+            
+            end_time = datetime.now()
+            duration = (end_time - start_time).total_seconds()
+            
+            # Memory cleanup
+            if self.device == "cpu":
+                gc.collect()
+            else:
+                torch.cuda.empty_cache()
+            
+            # Generate analysis report
+            analysis_info = self._generate_analysis_report(
+                analysis_summary, score, breakdown, duration
+            )
+            
+            return optimized_prompt, analysis_info, score, breakdown
+            
+        except Exception as e:
+            logger.error(f"Ultra supreme generation error: {e}")
+            return f"❌ Error: {str(e)}", "Please try with a different image.", 0, {}
+
+    def _detect_style(self, prompt: str) -> str:
+        """Detecta el estilo principal del prompt"""
+        styles = {
+            "portrait": ["portrait", "person", "face", "headshot"],
+            "landscape": ["landscape", "mountain", "nature", "scenery"],
+            "street": ["street", "urban", "city"],
+            "artistic": ["artistic", "abstract", "conceptual"],
+            "dramatic": ["dramatic", "cinematic", "moody"]
         }
         
-        return result
-    
-    def build_ultra_supreme_prompt(self, ultra_analysis: Dict[str, Any], clip_results: List[str]) -> str:
-        """Versión pública del método para compatibilidad"""
-        return self.build_ultra_supreme_prompt(ultra_analysis['elements'], clip_results)
-    
-    def calculate_ultra_supreme_score(self, prompt: str, ultra_analysis: Dict[str, Any]) -> Tuple[int, Dict[str, int]]:
-        """Calcula score basado en la riqueza del prompt generado"""
+        for style_name, keywords in styles.items():
+            if any(keyword in prompt.lower() for keyword in keywords):
+                return style_name
         
+        return "general"
+
+    def _detect_subject(self, prompt: str) -> str:
+        """Detecta el sujeto principal del prompt"""
+        # Tomar las primeras palabras significativas
+        words = prompt.split(',')[0].split()
+        if len(words) > 3:
+            return ' '.join(words[:4])
+        return prompt.split(',')[0]
+
+    def _calculate_score(self, optimized_prompt: str, base_prompt: str) -> int:
+        """Calcula el score basado en la calidad del prompt"""
         score = 0
-        breakdown = {}
         
-        # Estructura (20 puntos)
-        structure_score = 0
-        if prompt.startswith(("A ", "An ")):
-            structure_score += 10
-        if prompt.count(",") >= 5:
-            structure_score += 10
-        score += structure_score
-        breakdown["structure"] = structure_score
+        # Base score por longitud y riqueza
+        score += min(len(base_prompt) // 10, 25)
         
-        # Elementos únicos preservados (30 puntos)
-        unique_score = 0
-        if ultra_analysis.get('unique_features'):
-            unique_score += len(ultra_analysis['unique_features']) * 10
-        unique_score = min(unique_score, 30)
-        score += unique_score
-        breakdown["unique"] = unique_score
+        # Technical enhancement
+        if "Shot on" in optimized_prompt:
+            score += 25
         
-        # Contexto técnico (20 puntos)
-        tech_score = 0
-        if "Shot on" in prompt:
-            tech_score += 10
-        if any(term in prompt for term in ["f/", "mm"]):
-            tech_score += 10
-        score += tech_score
-        breakdown["technical"] = tech_score
+        # Lighting quality
+        if "lighting" in optimized_prompt.lower():
+            score += 25
         
-        # Mood y atmósfera (15 puntos)
-        mood_score = 0
-        if ultra_analysis.get('mood'):
-            mood_score += 15
-        score += mood_score
-        breakdown["mood"] = mood_score
+        # Professional quality
+        if any(word in optimized_prompt.lower() for word in ["professional", "masterful", "epic", "cinematic"]):
+            score += 25
         
-        # Calidad descriptiva (15 puntos)
-        desc_score = 0
-        if len(prompt) > 100:
-            desc_score += 10
-        if any(term in prompt for term in ["masterful", "epic", "cinematic", "exceptional"]):
-            desc_score += 5
-        score += desc_score
-        breakdown["descriptive"] = desc_score
+        return min(score, 100)
+
+    def _generate_analysis_report(self, analysis: Dict[str, Any], 
+                                  score: int, breakdown: Dict[str, int], 
+                                  duration: float) -> str:
+        """Generate detailed analysis report"""
+        
+        gpu_status = "⚡ ZeroGPU" if torch.cuda.is_available() else "💻 CPU"
+        
+        # Extraer información clave
+        detected_style = analysis.get("detected_style", "general").title()
+        detected_subject = analysis.get("detected_subject", "Unknown")
+        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  
+**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:** CLIP Interrogator → Flux Optimization → Technical Enhancement
+
+**📊 CLIP INTERROGATOR ANALYSIS:**
+- **Base Prompt:** {base_prompt_preview}
+- **Fast Analysis:** {analysis.get('clip_fast', '')[:80]}...
+- **Classic Analysis:** {analysis.get('clip_classic', '')[:80]}...
+
+**⚡ OPTIMIZATION APPLIED:**
+- ✅ Preserved CLIP Interrogator's rich description
+- ✅ Added professional camera specifications
+- ✅ Enhanced lighting descriptions
+- ✅ Applied Flux-specific optimizations
+- ✅ Removed redundant/generic elements
+
+**🔬 Powered by Pariente AI Research + CLIP Interrogator**"""
         
-        return min(score, 100), breakdown
+        return analysis_info