Update optimizer.py

optimizer.py

@@ -279,7 +279,7 @@ class UltraSupremeOptimizer:
             
             start_time = datetime.now()
             
-            logger.info("ULTRA SUPREME ANALYSIS - Starting pipeline")
+            logger.info("ULTRA SUPREME ANALYSIS - Starting complete pipeline with multi-model analysis")
             
             # Ejecutar inferencia CLIP
             full_prompt, clip_fast, clip_classic = self.run_clip_inference(image)
@@ -291,32 +291,47 @@ class UltraSupremeOptimizer:
                 clip_fast = "image"
                 clip_classic = "picture"
             
-            logger.info(f"Prompt completo: {full_prompt[:100]}...")
-            logger.info(f"Fast: {clip_fast[:50]}...")
-            logger.info(f"Classic: {clip_classic[:50]}...")
-            
-            # Aplicar reglas de Flux al prompt completo
-            optimized_prompt = self.apply_flux_rules(full_prompt)
-            
-            # Crear análisis para el reporte
-            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)
-            }
-            
-            # Calcular score
-            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())
+            logger.info(f"CLIP complete prompt: {full_prompt[:100]}...")
+            
+            # NUEVO: Ejecutar análisis ultra supremo con múltiples modelos
+            logger.info("Running multi-model ultra supreme analysis...")
+            ultra_analysis = self.analyzer.ultra_supreme_analysis(
+                image, clip_fast, clip_classic, full_prompt
+            )
+            
+            # Construir prompt mejorado basado en análisis completo
+            enhanced_prompt_parts = []
+            
+            # Base prompt de CLIP
+            enhanced_prompt_parts.append(full_prompt)
+            
+            # Agregar información demográfica si está disponible
+            if ultra_analysis["demographic"]["gender"] and ultra_analysis["demographic"]["gender_confidence"] > 0.7:
+                gender = ultra_analysis["demographic"]["gender"]
+                age_cat = ultra_analysis["demographic"]["age_category"]
+                if age_cat:
+                    enhanced_prompt_parts.append(f"{age_cat} {gender}")
+            
+            # Agregar estado emocional principal
+            if ultra_analysis["emotional_state"]["primary_emotion"] and ultra_analysis["emotional_state"]["emotion_confidence"] > 0.6:
+                emotion = ultra_analysis["emotional_state"]["primary_emotion"]
+                enhanced_prompt_parts.append(f"{emotion} expression")
+            
+            # Agregar información de pose si está disponible
+            if ultra_analysis["pose_composition"]["posture"]:
+                enhanced_prompt_parts.append(ultra_analysis["pose_composition"]["posture"][0])
+            
+            # Combinar y aplicar reglas de Flux
+            combined_prompt = ", ".join(enhanced_prompt_parts)
+            optimized_prompt = self.apply_flux_rules(combined_prompt)
+            
+            # Si el analyzer enriqueció el prompt, úsalo
+            analyzer_prompt = self.analyzer.build_ultra_supreme_prompt(ultra_analysis, [full_prompt])
+            if len(analyzer_prompt) > len(optimized_prompt):
+                optimized_prompt = self.apply_flux_rules(analyzer_prompt)
+            
+            # Calcular score usando el analyzer
+            score, breakdown = self.analyzer.calculate_ultra_supreme_score(optimized_prompt, ultra_analysis)
             
             end_time = datetime.now()
             duration = (end_time - start_time).total_seconds()
@@ -326,9 +341,9 @@ class UltraSupremeOptimizer:
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
             
-            # Generate analysis report
-            analysis_info = self._generate_analysis_report(
-                analysis_summary, score, breakdown, duration
+            # Generate enhanced analysis report con datos de múltiples modelos
+            analysis_info = self._generate_ultra_analysis_report(
+                ultra_analysis, score, breakdown, duration
             )
             
             return optimized_prompt, analysis_info, score, breakdown
@@ -386,45 +401,106 @@ class UltraSupremeOptimizer:
         
         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"""
+    def _generate_ultra_analysis_report(self, analysis: Dict[str, Any], 
+                                       score: int, breakdown: Dict[str, int], 
+                                       duration: float) -> str:
+        """Generate ultra detailed analysis report with multi-model results"""
         
         device_used = "cuda" if torch.cuda.is_available() else "cpu"
         gpu_status = "⚡ ZeroGPU" if device_used == "cuda" else "💻 CPU"
-        precision_info = "Half Precision (FP16)" if device_used == "cuda" else "Full Precision (FP32)"
         
-        # 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", "")
+        # Demographic info
+        demo_info = ""
+        if analysis["demographic"]["age_category"]:
+            age = analysis["demographic"]["age_category"].replace("_", " ").title()
+            gender = analysis["demographic"]["gender"] or "person"
+            confidence = analysis["demographic"]["age_confidence"]
+            demo_info = f"**Detected:** {age} {gender} (confidence: {confidence:.0%})"
+        
+        # Emotion info
+        emotion_info = ""
+        if analysis["emotional_state"]["primary_emotion"]:
+            emotion = analysis["emotional_state"]["primary_emotion"]
+            confidence = analysis["emotional_state"]["emotion_confidence"]
+            emotion_info = f"**Primary Emotion:** {emotion} ({confidence:.0%})"
+            
+            # Add emotion distribution if available
+            if analysis["emotional_state"]["emotion_distribution"]:
+                top_emotions = sorted(
+                    analysis["emotional_state"]["emotion_distribution"].items(),
+                    key=lambda x: x[1], reverse=True
+                )[:3]
+                emotion_details = ", ".join([f"{e[0]}: {e[1]:.0%}" for e in top_emotions])
+                emotion_info += f"\n**Emotion Distribution:** {emotion_details}"
         
-        analysis_info = f"""**🚀 ULTRA SUPREME ANALYSIS COMPLETE**
-**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}  
+        # Face analysis info
+        face_info = f"**Faces Detected:** {analysis['facial_ultra']['face_count']}"
+        if analysis['facial_ultra']['face_count'] > 0:
+            features = []
+            for feature_type in ['eyes', 'mouth', 'facial_hair', 'skin']:
+                if analysis['facial_ultra'].get(feature_type):
+                    features.extend(analysis['facial_ultra'][feature_type])
+            if features:
+                face_info += f"\n**Facial Features:** {', '.join(features[:5])}"
+        
+        # Pose info
+        pose_info = ""
+        if analysis["pose_composition"].get("pose_confidence", 0) > 0:
+            confidence = analysis["pose_composition"]["pose_confidence"]
+            pose_info = f"**Pose Analysis:** Body detected ({confidence:.0%} confidence)"
+            if analysis["pose_composition"]["posture"]:
+                pose_info += f"\n**Posture:** {', '.join(analysis['pose_composition']['posture'])}"
+        
+        # Environment info
+        env_info = ""
+        if analysis["environmental"]["setting_type"]:
+            env_info = f"**Setting:** {analysis['environmental']['setting_type'].replace('_', ' ').title()}"
+        if analysis["environmental"]["lighting_analysis"]:
+            env_info += f"\n**Lighting:** {', '.join(analysis['environmental']['lighting_analysis'])}"
+        
+        # Intelligence metrics
+        metrics = analysis["intelligence_metrics"]
+        
+        analysis_info = f"""**🚀 ULTRA SUPREME MULTI-MODEL ANALYSIS COMPLETE**
+**Processing:** {gpu_status} • {duration:.1f}s • Multi-Model Pipeline
+**Ultra Score:** {score}/100 • Models: CLIP + DeepFace + MediaPipe + Transformers
+
+**📊 BREAKDOWN:**
+• Prompt Quality: {breakdown.get('prompt_quality', 0)}/25
+• Analysis Depth: {breakdown.get('analysis_depth', 0)}/25  
+• Model Confidence: {breakdown.get('model_confidence', 0)}/25
+• Feature Richness: {breakdown.get('feature_richness', 0)}/25
+
+**🧠 DEEP ANALYSIS RESULTS:**
+
+**👤 DEMOGRAPHICS & IDENTITY:**
+{demo_info or "No face detected for demographic analysis"}
+
+**😊 EMOTIONAL ANALYSIS:**
+{emotion_info or "No emotional data available"}
+
+**👁️ FACIAL ANALYSIS:**
+{face_info}
+
+**🚶 POSE & BODY LANGUAGE:**
+{pose_info or "No pose data available"}
 
-**🧠 INTELLIGENT DETECTION:**
-- **Detected Style:** {detected_style}
-- **Main Subject:** {detected_subject}
-- **Precision:** Using {precision_info} for optimal performance
-- **Quality:** Maximum resolution processing (768px)
+**🏞️ ENVIRONMENT & SCENE:**
+{env_info or "No environmental data detected"}
 
-**📊 CLIP INTERROGATOR ANALYSIS:**
-- **Base Prompt:** {base_prompt_preview}
-- **Fast Analysis:** {analysis.get('clip_fast', '')[:80]}...
-- **Classic Analysis:** {analysis.get('clip_classic', '')[:80]}...
+**📊 INTELLIGENCE METRICS:**
+• **Total Features Detected:** {metrics['total_features_detected']}
+• **Analysis Depth Score:** {metrics['analysis_depth_score']}/100
+• **Model Confidence Average:** {metrics['model_confidence_average']:.0%}
+• **Technical Optimization:** {metrics['technical_optimization_score']}/100
 
-**⚡ OPTIMIZATION APPLIED:**
-- ✅ Mixed precision handling for stability
-- ✅ Automatic GPU/CPU fallback
-- ✅ Memory-efficient processing
-- ✅ Added professional camera specifications
-- ✅ Enhanced lighting descriptions
-- ✅ Applied Flux-specific optimizations
-- ✅ Removed redundant/generic elements
+**✨ MULTI-MODEL ADVANTAGES:**
+✅ DeepFace: Accurate age, gender, emotion detection
+✅ MediaPipe: Body pose and gesture analysis
+✅ CLIP: Semantic understanding and context
+✅ Transformers: Advanced emotion classification
+✅ OpenCV: Robust face detection
 
-**🔬 Powered by Pariente AI Research + CLIP Interrogator**"""
+**🔬 Powered by Pariente AI Research • Ultra Supreme Intelligence Engine**"""
         
         return analysis_info