Optimize pipeline for fast responses - disable RL overhead for instant character extraction

src/__init__.py

@@ -0,0 +1 @@
+# Make src a Python package

src/app.py

@@ -21,10 +21,10 @@ try:
     warnings.filterwarnings("ignore", message=".*protobuf.*")
     warnings.filterwarnings("ignore", message=".*MessageFactory.*")
     
-    from character_pipeline import create_pipeline
-    from pipeline import CharacterAttributes
-    from pipeline.input_loader import DatasetItem
-    from rl_trainer import train_rl_pipeline
+    from src.character_pipeline import create_pipeline
+    from src.pipeline import CharacterAttributes
+    from src.pipeline.input_loader import DatasetItem
+    from src.rl_trainer import train_rl_pipeline
     PIPELINE_AVAILABLE = True
 except (ImportError, AttributeError) as e:
     logging.warning(f"Pipeline dependencies not available: {e}")
@@ -76,10 +76,14 @@ class UnifiedCharacterExtractionApp:
         try:
             if PIPELINE_AVAILABLE:
                 self.pipeline = create_pipeline({
-                    'use_rl_primary': True,
-                    'rl_model_path': 'decision_transformer.pth' if Path('decision_transformer.pth').exists() else None
+                    'use_rl_primary': False,
+                    'rl_model_path': None,
+                    'enable_caching': True,
+                    'batch_size': 1,
+                    'fast_mode': True,
+                    'disable_ray': True
                 })
-                logger.info("RL Pipeline initialized successfully")
+                logger.info("Fast Pipeline initialized successfully")
             else:
                 self.pipeline = None
                 logger.info("Running in fallback mode - dependencies loading...")
@@ -436,8 +440,10 @@ def main():
     
     port = int(os.environ.get("PORT", 7860))
     
+    interface.queue()  # Enable queue for Gradio 3.50.0
+    
     interface.launch(
-        server_name="0.0.0.0",
+        server_name="127.0.0.1",
         server_port=port,
         share=False,
         show_error=True

src/app_simple_working.py

@@ -0,0 +1,166 @@
+import gradio as gr
+import json
+import time
+import os
+from pathlib import Path
+from PIL import Image
+from typing import Dict, List, Tuple, Any
+import logging
+import sys
+
+# Add src to path for imports
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Simple imports without complex dependencies
+try:
+    from src.character_pipeline import create_pipeline
+    PIPELINE_AVAILABLE = True
+    print("✅ RL Pipeline loaded successfully!")
+except Exception as e:
+    print(f"⚠️ Pipeline not available: {e}")
+    PIPELINE_AVAILABLE = False
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class SimpleCharacterApp:
+    def __init__(self):
+        self.pipeline = None
+        if PIPELINE_AVAILABLE:
+            try:
+                self.pipeline = create_pipeline({
+                    'use_rl_primary': True,
+                    'rl_model_path': None
+                })
+                logger.info("✅ RL Pipeline initialized successfully")
+            except Exception as e:
+                logger.error(f"❌ Pipeline initialization failed: {e}")
+                self.pipeline = None
+    
+    def extract_attributes(self, image):
+        if image is None:
+            return "Please upload an image first.", "{}", "No image provided"
+        
+        try:
+            start_time = time.time()
+            
+            if self.pipeline and PIPELINE_AVAILABLE:
+                # Use real RL pipeline
+                attributes = self.pipeline.extract_from_image(image)
+                processing_time = time.time() - start_time
+                
+                # Format output
+                formatted_output = "**🎭 Character Attributes Extracted:**\n\n"
+                attr_dict = attributes.to_dict() if hasattr(attributes, 'to_dict') else {
+                    "Age": getattr(attributes, 'age', 'Unknown'),
+                    "Gender": getattr(attributes, 'gender', 'Unknown'),
+                    "Hair Color": getattr(attributes, 'hair_color', 'Unknown'),
+                    "Eye Color": getattr(attributes, 'eye_color', 'Unknown'),
+                    "Confidence": getattr(attributes, 'confidence_score', 0.0)
+                }
+                
+                for key, value in attr_dict.items():
+                    if key == "Confidence" or "Score" in key:
+                        formatted_output += f"**{key}:** {value:.3f}\n"
+                    else:
+                        formatted_output += f"**{key}:** {value}\n"
+                
+                json_output = json.dumps(attr_dict, indent=2)
+                stats = f"⚡ Processing Time: {processing_time:.2f}s\n🤖 Mode: RL Pipeline\n✅ Status: Success"
+                
+            else:
+                # Fallback mode with basic analysis
+                processing_time = time.time() - start_time
+                
+                # Simple mock attributes
+                attr_dict = {
+                    "Age": "Young Adult",
+                    "Gender": "Unknown",
+                    "Hair Color": "Unknown", 
+                    "Eye Color": "Unknown",
+                    "Confidence": 0.5
+                }
+                
+                formatted_output = "**🎭 Character Attributes (Fallback Mode):**\n\n"
+                for key, value in attr_dict.items():
+                    if key == "Confidence":
+                        formatted_output += f"**{key}:** {value:.3f}\n"
+                    else:
+                        formatted_output += f"**{key}:** {value}\n"
+                
+                json_output = json.dumps(attr_dict, indent=2)
+                stats = f"⚡ Processing Time: {processing_time:.2f}s\n🔄 Mode: Fallback\n⚠️ Status: Limited functionality"
+            
+            return formatted_output, json_output, stats
+            
+        except Exception as e:
+            error_msg = f"❌ Error processing image: {str(e)}"
+            logger.error(error_msg)
+            
+            error_dict = {
+                "error": str(e),
+                "status": "error"
+            }
+            return error_msg, json.dumps(error_dict, indent=2), "❌ Processing failed"
+
+def create_interface():
+    app = SimpleCharacterApp()
+    
+    with gr.Blocks(title="RL Character Extraction") as interface:
+        gr.Markdown("""
+        # 🎭 RL-Enhanced Character Attribute Extraction
+        
+        Upload a character image to extract detailed attributes using our RL-powered pipeline.
+        """)
+        
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(
+                    type="pil",
+                    label="📸 Upload Character Image"
+                )
+                
+                extract_btn = gr.Button(
+                    "🚀 Extract Attributes",
+                    variant="primary"
+                )
+            
+            with gr.Column():
+                formatted_output = gr.Markdown(
+                    label="📋 Extracted Attributes",
+                    value="Upload an image and click 'Extract Attributes' to see results."
+                )
+                
+                stats_output = gr.Textbox(
+                    label="📊 Processing Stats",
+                    lines=3
+                )
+        
+        json_output = gr.Code(
+            label="📄 JSON Output",
+            language="json"
+        )
+        
+        extract_btn.click(
+            fn=app.extract_attributes,
+            inputs=[image_input],
+            outputs=[formatted_output, json_output, stats_output]
+        )
+    
+    return interface
+
+def main():
+    logger.info("🚀 Starting Simple Character Attribute Extraction Interface...")
+    
+    interface = create_interface()
+    port = int(os.environ.get("PORT", 7860))
+    
+    interface.launch(
+        server_name="127.0.0.1",
+        server_port=port,
+        share=False,
+        show_error=True
+    )
+
+if __name__ == "__main__":
+    main()

src/character_pipeline.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, List, Optional, Union
 from PIL import Image
 import asyncio
 
-from pipeline import (
+from src.pipeline import (
     Pipeline,
     PipelineStage,
     CharacterAttributes,
@@ -25,7 +25,7 @@ from pipeline import (
     DistributedProcessor,
     AdvancedCacheManager,
 )
-from rl_pipeline_integration import create_rl_enhanced_pipeline, ProductionRLPipeline
+from src.rl_pipeline_integration import create_rl_enhanced_pipeline, ProductionRLPipeline
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)

src/rl_pipeline_integration.py

@@ -6,11 +6,17 @@ import torch
 from pathlib import Path
 import json
 import time
-from rl_orchestrator import RLOrchestrator, StateVector
-from rl_trainer import train_rl_pipeline
-from pipeline.base import CharacterAttributes, ProcessingResult
-from pipeline.input_loader import DatasetItem
-import ray
+from src.rl_orchestrator import RLOrchestrator, StateVector
+from src.rl_trainer import train_rl_pipeline
+from src.pipeline.base import CharacterAttributes, ProcessingResult
+from src.pipeline.input_loader import DatasetItem
+# import ray  # Disabled to avoid GPU resource conflicts
+try:
+    import ray
+    RAY_AVAILABLE = True
+except ImportError:
+    RAY_AVAILABLE = False
+    ray = None
 
 class ProductionRLPipeline:
     def __init__(self, model_path: Optional[str] = None, enable_training: bool = False):
@@ -24,6 +30,20 @@ class ProductionRLPipeline:
             "avg_cost": 0.0,
             "success_rate": 0.0
         }
+        
+        # Initialize Ray for distributed processing (if available)
+        if RAY_AVAILABLE and not ray.is_initialized():
+            try:
+                ray.init(ignore_reinit_error=True, log_to_driver=False, num_cpus=2, num_gpus=0)
+                self.use_ray = True
+            except Exception as e:
+                print(f"Ray initialization failed: {e}. Running without distributed processing.")
+                self.use_ray = False
+        elif not RAY_AVAILABLE:
+            print("Ray not available. Running without distributed processing.")
+            self.use_ray = False
+        else:
+            self.use_ray = True
     
     async def extract_attributes_rl(self, image: Union[str, Path, Image.Image], 
                                    tags: Optional[str] = None,