Update app.py

app.py

@@ -11,7 +11,6 @@ from datetime import datetime
 import gc
 import re
 
-# Suppress warnings
 warnings.filterwarnings("ignore", category=FutureWarning)
 warnings.filterwarnings("ignore", category=UserWarning)
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
@@ -29,185 +28,265 @@ def get_device():
 
 DEVICE = get_device()
 
-class FluxRulesEngine:
+class DeepFluxAnalyzer:
     """
-    Flux prompt optimization based on Pariente AI research
-    Implements structured prompt generation following validated rules
+    Deep analysis engine that understands image content and applies Flux rules intelligently
     """
     
     def __init__(self):
         self.forbidden_elements = ["++", "weights", "white background [en dev]"]
         
-        self.articles = ["a", "an", "the"]
-        self.quality_adjectives = [
-            "majestic", "pristine", "sleek", "elegant", "dramatic", 
-            "cinematic", "professional", "stunning", "refined"
-        ]
-        
-        self.lighting_types = [
-            "golden hour", "studio lighting", "dramatic lighting",
-            "ambient lighting", "natural light", "soft lighting",
-            "rim lighting", "volumetric lighting"
-        ]
-        
-        self.technical_specs = [
-            "Shot on Phase One", "f/2.8 aperture", "50mm lens",
-            "85mm lens", "35mm lens", "professional photography",
-            "medium format", "high resolution"
-        ]
-        
-        self.materials = [
-            "metallic", "glass", "chrome", "leather", "fabric",
-            "wood", "concrete", "steel", "ceramic"
-        ]
-    
-    def extract_subject(self, base_prompt):
-        """Extract main subject from CLIP analysis"""
-        words = base_prompt.lower().split()
-        
-        # Common subjects to identify
-        subjects = [
-            "car", "vehicle", "automobile", "person", "man", "woman", 
-            "building", "house", "landscape", "mountain", "tree",
-            "flower", "animal", "dog", "cat", "bird"
-        ]
-        
-        for word in words:
-            if word in subjects:
-                return word
-                
-        # Fallback to first noun-like word
-        return words[0] if words else "subject"
-    
-    def detect_setting(self, base_prompt):
-        """Detect environmental context"""
-        prompt_lower = base_prompt.lower()
-        
-        settings = {
-            "studio": ["studio", "backdrop", "seamless"],
-            "outdoor": ["outdoor", "outside", "landscape", "nature"],
-            "urban": ["city", "street", "urban", "building"],
-            "coastal": ["beach", "ocean", "coast", "sea"],
-            "indoor": ["room", "interior", "inside", "home"]
+        # Deep vocabulary for intelligent analysis
+        self.age_descriptors = {
+            "young": ["young", "youthful", "fresh-faced"],
+            "middle": ["middle-aged", "mature"], 
+            "elderly": ["elderly", "aged", "distinguished", "weathered"]
         }
         
-        for setting, keywords in settings.items():
-            if any(keyword in prompt_lower for keyword in keywords):
-                return setting
-                
-        return "neutral environment"
+        self.facial_features = {
+            "beard": ["bearded", "with a full beard", "with facial hair", "with a silver beard", "with a gray beard"],
+            "glasses": ["wearing glasses", "with wire-frame glasses", "with spectacles", "with eyeglasses"],
+            "eyes": ["intense gaze", "piercing eyes", "contemplative expression", "focused stare"]
+        }
+        
+        self.clothing_religious = {
+            "hat": ["black hat", "traditional hat", "religious headwear", "Orthodox hat"],
+            "clothing": ["traditional clothing", "religious attire", "formal wear", "dark clothing"]
+        }
+        
+        self.settings_detailed = {
+            "indoor": ["indoor setting", "interior space", "indoor environment"],
+            "outdoor": ["outdoor setting", "natural environment", "exterior location"],
+            "studio": ["studio setting", "controlled environment", "professional backdrop"]
+        }
+        
+        self.lighting_advanced = {
+            "portrait": ["dramatic portrait lighting", "studio portrait lighting", "professional portrait setup"],
+            "natural": ["natural lighting", "window light", "ambient illumination"],
+            "dramatic": ["dramatic lighting", "high contrast lighting", "chiaroscuro lighting"]
+        }
+        
+        self.technical_professional = {
+            "portrait_lens": ["85mm lens", "135mm lens", "medium telephoto"],
+            "standard_lens": ["50mm lens", "35mm lens", "standard focal length"],
+            "aperture": ["f/1.4 aperture", "f/2.8 aperture", "f/4 aperture"],
+            "camera": ["Shot on Phase One XF", "Shot on Hasselblad", "Shot on Canon EOS R5"]
+        }
     
-    def optimize_for_flux(self, base_prompt, style_preference="professional"):
-        """Apply Flux-specific optimization rules"""
+    def analyze_clip_deeply(self, clip_result):
+        """Extract detailed information from CLIP analysis"""
+        clip_lower = clip_result.lower()
+        analysis = {
+            "subjects": [],
+            "age": None,
+            "features": [],
+            "clothing": [],
+            "setting": None,
+            "mood": None,
+            "composition": None
+        }
         
-        # Clean forbidden elements
-        cleaned_prompt = base_prompt
-        for forbidden in self.forbidden_elements:
-            cleaned_prompt = cleaned_prompt.replace(forbidden, "")
+        # Subject and age detection
+        if any(word in clip_lower for word in ["man", "person", "male"]):
+            if any(word in clip_lower for word in ["old", "elderly", "aged", "gray", "grey", "silver"]):
+                analysis["subjects"].append("elderly man")
+                analysis["age"] = "elderly"
+            elif any(word in clip_lower for word in ["young", "youth", "boy"]):
+                analysis["subjects"].append("young man")  
+                analysis["age"] = "young"
+            else:
+                analysis["subjects"].append("man")
+                analysis["age"] = "middle"
         
-        # Extract key elements
-        subject = self.extract_subject(base_prompt)
-        setting = self.detect_setting(base_prompt)
+        if any(word in clip_lower for word in ["woman", "female", "lady"]):
+            if any(word in clip_lower for word in ["old", "elderly", "aged"]):
+                analysis["subjects"].append("elderly woman")
+                analysis["age"] = "elderly"
+            else:
+                analysis["subjects"].append("woman")
         
-        # Build structured prompt
+        # Facial features detection
+        if any(word in clip_lower for word in ["beard", "facial hair", "mustache"]):
+            if any(word in clip_lower for word in ["gray", "grey", "silver", "white"]):
+                analysis["features"].append("silver beard")
+            else:
+                analysis["features"].append("beard")
+        
+        if any(word in clip_lower for word in ["glasses", "spectacles", "eyeglasses"]):
+            analysis["features"].append("glasses")
+        
+        # Clothing and accessories
+        if any(word in clip_lower for word in ["hat", "cap", "headwear"]):
+            analysis["clothing"].append("hat")
+        
+        if any(word in clip_lower for word in ["suit", "formal", "dress", "shirt"]):
+            analysis["clothing"].append("formal wear")
+            
+        # Setting detection  
+        if any(word in clip_lower for word in ["indoor", "inside", "interior", "room"]):
+            analysis["setting"] = "indoor"
+        elif any(word in clip_lower for word in ["outdoor", "outside", "landscape", "street"]):
+            analysis["setting"] = "outdoor"
+        elif any(word in clip_lower for word in ["studio", "backdrop"]):
+            analysis["setting"] = "studio"
+        
+        # Mood and composition
+        if any(word in clip_lower for word in ["portrait", "headshot", "face", "close-up"]):
+            analysis["composition"] = "portrait"
+        elif any(word in clip_lower for word in ["sitting", "seated", "chair"]):
+            analysis["composition"] = "seated"
+        elif any(word in clip_lower for word in ["standing", "upright"]):
+            analysis["composition"] = "standing"
+            
+        return analysis
+    
+    def build_flux_prompt(self, analysis, clip_base):
+        """Build optimized Flux prompt using deep analysis"""
         components = []
         
-        # 1. Article
-        article = "A" if subject[0] not in 'aeiou' else "An"
+        # 1. Article (intelligent selection)
+        if analysis["subjects"]:
+            subject = analysis["subjects"][0]
+            article = "An" if subject[0] in 'aeiou' else "A"
+        else:
+            article = "A"
         components.append(article)
         
-        # 2. Descriptive adjectives (max 2-3)
-        adjectives = ["elegant", "professional"]  # Fixed instead of random
-        components.extend(adjectives)
+        # 2. Descriptive adjectives (context-aware)
+        adjectives = []
+        if analysis["age"] == "elderly":
+            adjectives.extend(["distinguished", "weathered"])
+        elif analysis["age"] == "young":
+            adjectives.extend(["young", "fresh-faced"])
+        else:
+            adjectives.extend(["professional", "elegant"])
         
-        # 3. Main subject
-        components.append(subject)
+        # Add up to 2-3 adjectives as per Flux rules
+        components.extend(adjectives[:2])
         
-        # 4. Verb/Action (gerund form)
-        if "person" in subject or "man" in subject or "woman" in subject:
-            action = "standing"
+        # 3. Main subject (enhanced with details)
+        if analysis["subjects"]:
+            main_subject = analysis["subjects"][0]
+            # Add religious/cultural context if detected
+            if "hat" in analysis["clothing"] and "beard" in [f.split()[0] for f in analysis["features"]]:
+                main_subject = "Orthodox Jewish " + main_subject
         else:
-            action = "positioned"
-        components.append(action)
+            main_subject = "subject"
+        components.append(main_subject)
+        
+        # 4. Features integration (intelligent placement)
+        feature_descriptions = []
+        if "glasses" in analysis["features"]:
+            feature_descriptions.append("with distinctive wire-frame glasses")
+        if any("beard" in f for f in analysis["features"]):
+            if "silver beard" in analysis["features"]:
+                feature_descriptions.append("with a distinguished silver beard")
+            else:
+                feature_descriptions.append("with a full beard")
         
-        # 5. Context/Location
-        context_map = {
-            "studio": "in a professional studio setting",
-            "outdoor": "in a natural outdoor environment", 
-            "urban": "on an urban street",
-            "coastal": "along a dramatic coastline",
-            "indoor": "in an elegant interior space"
-        }
-        components.append(context_map.get(setting, "in a carefully composed scene"))
+        if feature_descriptions:
+            components.extend(feature_descriptions)
         
-        # 6. Environmental details
-        components.append("with subtle atmospheric effects")
+        # 5. Clothing and accessories
+        clothing_desc = []
+        if "hat" in analysis["clothing"]:
+            clothing_desc.append("wearing a traditional black hat")
+        if "formal wear" in analysis["clothing"]:
+            clothing_desc.append("in formal attire")
+            
+        if clothing_desc:
+            components.extend(clothing_desc)
+        
+        # 6. Verb/Action (based on composition analysis)
+        if analysis["composition"] == "seated":
+            action = "seated contemplatively"
+        elif analysis["composition"] == "standing":
+            action = "standing with dignity"
+        else:
+            action = "positioned thoughtfully"
+        components.append(action)
         
-        # 7. Materials/Textures (if applicable)
-        if any(mat in base_prompt.lower() for mat in ["car", "vehicle", "metal"]):
-            components.append("featuring metallic surfaces")
+        # 7. Context/Location (enhanced setting)
+        setting_map = {
+            "indoor": "in an intimate indoor setting",
+            "outdoor": "in a natural outdoor environment",
+            "studio": "in a professional studio environment"
+        }
         
-        # 8. Lighting effects
-        components.append("illuminated by golden hour lighting")
+        if analysis["setting"]:
+            context = setting_map.get(analysis["setting"], "in a carefully composed environment")
+        else:
+            context = "in a thoughtfully arranged scene"
+        components.append(context)
         
-        # 9. Technical specs
-        components.append("Shot on Phase One, f/2.8 aperture")
+        # 8. Environmental details (lighting-aware)
+        if analysis["composition"] == "portrait":
+            env_detail = "with dramatic portrait lighting that emphasizes facial features and texture"
+        else:
+            env_detail = "captured with sophisticated atmospheric lighting"
+        components.append(env_detail)
         
-        # 10. Quality/Style
-        if style_preference == "cinematic":
-            quality = "cinematic composition"
-        elif style_preference == "commercial":
-            quality = "commercial photography quality"
+        # 9. Technical specifications (composition-appropriate)
+        if analysis["composition"] == "portrait":
+            tech_spec = "Shot on Phase One XF, 85mm lens, f/2.8 aperture"
         else:
-            quality = "professional photography"
-            
-        components.append(quality)
+            tech_spec = "Shot on Phase One, 50mm lens, f/4 aperture"
+        components.append(tech_spec)
         
-        # Join components with proper punctuation
+        # 10. Quality marker (always professional)
+        components.append("professional photography")
+        
+        # Join with proper punctuation
         prompt = ", ".join(components)
         
-        # Capitalize first letter
-        prompt = prompt[0].upper() + prompt[1:]
+        # Clean up and optimize
+        prompt = re.sub(r'\s+', ' ', prompt)  # Remove extra spaces
+        prompt = prompt.replace(", ,", ",")   # Remove double commas
         
         return prompt
     
-    def get_optimization_score(self, prompt):
-        """Calculate optimization score for Flux compatibility"""
+    def calculate_intelligence_score(self, prompt, analysis):
+        """Calculate how well the prompt reflects intelligent analysis"""
         score = 0
         
-        # Structure check (order compliance)
-        if prompt.startswith(("A", "An", "The")):
+        # Structure compliance (Flux rules 1-10)
+        if prompt.startswith(("A", "An")):
+            score += 10
+            
+        # Feature recognition accuracy
+        if len(analysis["features"]) > 0:
             score += 15
             
-        # Technical specs presence
-        if any(spec in prompt for spec in self.technical_specs):
-            score += 20
+        # Context understanding
+        if analysis["setting"]:
+            score += 15
             
-        # Lighting specification
-        if any(light in prompt.lower() for light in self.lighting_types):
+        # Subject detail depth
+        if len(analysis["subjects"]) > 0:
             score += 15
             
-        # No forbidden elements
-        if not any(forbidden in prompt for forbidden in self.forbidden_elements):
+        # Technical specs presence
+        if "Phase One" in prompt and "lens" in prompt:
             score += 15
             
-        # Proper punctuation and structure
-        if "," in prompt:
+        # Lighting specification
+        if "lighting" in prompt:
             score += 10
             
-        # Length optimization
-        word_count = len(prompt.split())
-        if 15 <= word_count <= 35:
-            score += 25
-        elif 10 <= word_count <= 45:
-            score += 15
+        # Composition awareness
+        if analysis["composition"]:
+            score += 10
+            
+        # Forbidden elements check
+        if not any(forbidden in prompt for forbidden in self.forbidden_elements):
+            score += 10
             
         return min(score, 100)
 
 class FluxPromptOptimizer:
     def __init__(self):
         self.interrogator = None
-        self.flux_engine = FluxRulesEngine()
+        self.analyzer = DeepFluxAnalyzer()
         self.usage_count = 0
         self.device = DEVICE
         self.is_initialized = False
@@ -251,7 +330,6 @@ class FluxPromptOptimizer:
         if image.mode != 'RGB':
             image = image.convert('RGB')
         
-        # Optimize image size for processing
         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)
@@ -259,7 +337,7 @@ class FluxPromptOptimizer:
         return image
     
     @spaces.GPU
-    def generate_optimized_prompt(self, image, style_preference="professional", mode="best"):
+    def generate_optimized_prompt(self, image):
         try:
             if not self.is_initialized:
                 if not self.initialize_model():
@@ -276,22 +354,17 @@ class FluxPromptOptimizer:
             
             start_time = datetime.now()
             
-            # Get base analysis from CLIP
-            try:
-                if mode == "fast":
-                    base_prompt = self.interrogator.interrogate_fast(image)
-                elif mode == "classic":
-                    base_prompt = self.interrogator.interrogate_classic(image)
-                else:
-                    base_prompt = self.interrogator.interrogate(image)
-            except Exception as e:
-                base_prompt = self.interrogator.interrogate_fast(image)
+            # Get comprehensive CLIP analysis
+            clip_result = self.interrogator.interrogate(image)
+            
+            # Deep analysis of the CLIP result
+            deep_analysis = self.analyzer.analyze_clip_deeply(clip_result)
             
-            # Apply Flux-specific optimization
-            optimized_prompt = self.flux_engine.optimize_for_flux(base_prompt, style_preference)
+            # Build optimized Flux prompt
+            optimized_prompt = self.analyzer.build_flux_prompt(deep_analysis, clip_result)
             
-            # Calculate optimization score
-            score = self.flux_engine.get_optimization_score(optimized_prompt)
+            # Calculate intelligence score
+            score = self.analyzer.calculate_intelligence_score(optimized_prompt, deep_analysis)
             
             end_time = datetime.now()
             duration = (end_time - start_time).total_seconds()
@@ -302,18 +375,26 @@ class FluxPromptOptimizer:
             else:
                 torch.cuda.empty_cache()
             
-            # Generate analysis info
+            # Generate detailed analysis info
             gpu_status = "⚡ ZeroGPU" if torch.cuda.is_available() else "💻 CPU"
             
-            analysis_info = f"""**Analysis Complete**
+            features_detected = ", ".join(deep_analysis["features"]) if deep_analysis["features"] else "None"
+            subjects_detected = ", ".join(deep_analysis["subjects"]) if deep_analysis["subjects"] else "Generic"
+            
+            analysis_info = f"""**Deep Analysis Complete**
 
-**Processing:** {gpu_status} • {duration:.1f}s • {mode.title()} mode  
-**Style:** {style_preference.title()} photography  
-**Optimization Score:** {score}/100  
+**Processing:** {gpu_status} • {duration:.1f}s  
+**Intelligence Score:** {score}/100  
 **Generation:** #{self.usage_count}  
 
-**Base Analysis:** {base_prompt[:100]}...  
-**Enhancement:** Applied Flux-specific structure and terminology"""
+**Detected Elements:**
+• **Subjects:** {subjects_detected}
+• **Features:** {features_detected}  
+• **Setting:** {deep_analysis["setting"] or "Unspecified"}
+• **Composition:** {deep_analysis["composition"] or "Standard"}
+
+**CLIP Base:** {clip_result[:80]}...  
+**Flux Enhancement:** Applied deep analysis with Pariente AI rules"""
             
             return optimized_prompt, analysis_info, score
             
@@ -323,17 +404,17 @@ class FluxPromptOptimizer:
 
 optimizer = FluxPromptOptimizer()
 
-def process_image_wrapper(image, style_preference, mode):
-    """Simple wrapper without progress callbacks"""
+def process_image_wrapper(image):
+    """Simplified wrapper - no unnecessary options"""
     try:
-        prompt, info, score = optimizer.generate_optimized_prompt(image, style_preference, mode)
+        prompt, info, score = optimizer.generate_optimized_prompt(image)
         
         # Create score HTML
         color = "#22c55e" if score >= 80 else "#f59e0b" if score >= 60 else "#ef4444"
         score_html = f'''
         <div style="text-align: center; padding: 1rem; background: linear-gradient(135deg, #f0fdf4 0%, #dcfce7 100%); border: 2px solid {color}; border-radius: 12px; margin: 1rem 0;">
             <div style="font-size: 2rem; font-weight: 700; color: {color}; margin: 0;">{score}</div>
-            <div style="font-size: 0.875rem; color: #15803d; margin: 0; text-transform: uppercase; letter-spacing: 0.05em;">Optimization Score</div>
+            <div style="font-size: 0.875rem; color: #15803d; margin: 0; text-transform: uppercase; letter-spacing: 0.05em;">Intelligence Score</div>
         </div>
         '''
         
@@ -347,10 +428,9 @@ def clear_outputs():
     gc.collect()
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
-    return "", "", '<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Optimization Score</div></div>'
+    return "", "", '<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Intelligence Score</div></div>'
 
 def create_interface():
-    # Professional CSS with elegant typography
     css = """
     @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
     
@@ -409,76 +489,73 @@ def create_interface():
         gr.HTML("""
         <div class="main-header">
             <div class="main-title">⚡ Flux Prompt Optimizer</div>
-            <div class="subtitle">Advanced prompt generation for Flux models • Research-based optimization</div>
+            <div class="subtitle">Deep AI analysis • Intelligent prompt generation • Research-based optimization</div>
         </div>
         """)
         
         with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("## 📷 Image Input")
+                gr.Markdown("## 📷 Image Analysis")
                 
                 image_input = gr.Image(
                     label="Upload your image",
                     type="pil",
-                    height=320
-                )
-                
-                gr.Markdown("## ⚙️ Settings")
-                
-                style_selector = gr.Dropdown(
-                    choices=["professional", "cinematic", "commercial", "artistic"],
-                    value="professional",
-                    label="Photography Style"
-                )
-                
-                mode_selector = gr.Dropdown(
-                    choices=["fast", "classic", "best"],
-                    value="best",
-                    label="Analysis Mode"
+                    height=400
                 )
                 
                 optimize_btn = gr.Button(
-                    "🚀 Generate Optimized Prompt",
+                    "🧠 Analyze & Optimize",
                     variant="primary",
                     size="lg"
                 )
+                
+                gr.Markdown("""
+                ### Deep Analysis Engine
+                
+                This system performs comprehensive image analysis:
+                
+                • **Subject Recognition** - Identifies people, objects, context
+                • **Feature Detection** - Facial features, clothing, accessories  
+                • **Composition Analysis** - Lighting, setting, mood
+                • **Flux Optimization** - Applies research-validated rules
+                
+                No options needed - the AI decides what's optimal.
+                """)
             
             with gr.Column(scale=1):
-                gr.Markdown("## 📝 Optimized Prompt")
+                gr.Markdown("## 🎯 Optimized Result")
                 
                 prompt_output = gr.Textbox(
-                    label="Generated Prompt",
-                    placeholder="Your optimized Flux prompt will appear here...",
-                    lines=6,
-                    max_lines=10,
+                    label="Flux-Optimized Prompt",
+                    placeholder="Upload an image to see the intelligent analysis and optimization...",
+                    lines=8,
+                    max_lines=12,
                     elem_classes=["prompt-output"],
                     show_copy_button=True
                 )
                 
                 score_output = gr.HTML(
-                    value='<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Optimization Score</div></div>'
+                    value='<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Intelligence Score</div></div>'
                 )
                 
                 info_output = gr.Markdown(value="")
                 
-                with gr.Row():
-                    clear_btn = gr.Button("🗑️ Clear", size="sm")
+                clear_btn = gr.Button("🗑️ Clear", size="sm")
         
         gr.Markdown("""
         ---
-        ### 🔬 Research Foundation
+        ### 🔬 Pariente AI Research Foundation
         
-        Flux Prompt Optimizer implements validated prompt engineering research for optimal Flux model performance. 
-        The optimization engine applies structured composition rules, technical terminology, and quality markers 
-        specifically calibrated for Flux architecture.
+        This optimizer implements deep computer vision analysis combined with validated Flux prompt engineering rules. 
+        The system intelligently recognizes image content and applies structured optimization without requiring user configuration.
         
-        **Developed by Pariente AI** • Advanced AI Research Laboratory
+        **Research-based • Intelligence-driven • Zero configuration needed**
         """)
         
-        # Event handlers - FIXED
+        # Simple event handlers
         optimize_btn.click(
             fn=process_image_wrapper,
-            inputs=[image_input, style_selector, mode_selector],
+            inputs=[image_input],
             outputs=[prompt_output, info_output, score_output]
         )
         
@@ -490,7 +567,7 @@ def create_interface():
     return interface
 
 if __name__ == "__main__":
-    logger.info("🚀 Starting Flux Prompt Optimizer")
+    logger.info("🚀 Starting Deep Flux Prompt Optimizer")
     interface = create_interface()
     interface.launch(
         server_name="0.0.0.0",