Upload app.py with huggingface_hub

app.py

@@ -1,234 +1,473 @@
-#!/usr/bin/env python3
-"""
-Hugging Face Space App for Financial Sentiment Analysis Ensemble
-"""
-
-import gradio as gr
-import torch
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import numpy as np
-from datetime import datetime
-import json
-
-class FinancialSentimentEnsemble:
-    def __init__(self):
-        self.models = {}
-        self.tokenizers = {}
-        self.model_names = [
-            "codealchemist01/financial-sentiment-distilbert",
-            "codealchemist01/financial-sentiment-bert-large", 
-            "codealchemist01/financial-sentiment-improved"
-        ]
-        self.labels = ["Bearish 📉", "Neutral ➡️", "Bullish 📈"]
-        self.load_models()
-    
-    def load_models(self):
-        """Load all models and tokenizers"""
-        print("🚀 Loading Financial Sentiment Analysis Ensemble...")
-        
-        for i, model_name in enumerate(self.model_names):
-            try:
-                print(f"📥 Loading {model_name}...")
-                self.tokenizers[i] = AutoTokenizer.from_pretrained(model_name)
-                self.models[i] = AutoModelForSequenceClassification.from_pretrained(model_name)
-                self.models[i].eval()
-                print(f"✅ {model_name} loaded successfully!")
-            except Exception as e:
-                print(f"❌ Error loading {model_name}: {e}")
-        
-        print(f"🎉 Ensemble ready with {len(self.models)} models!")
-    
-    def predict_single_model(self, text, model_idx):
-        """Predict sentiment using a single model"""
-        if model_idx not in self.models:
-            return None
-            
-        try:
-            inputs = self.tokenizers[model_idx](
-                text, 
-                return_tensors="pt", 
-                truncation=True, 
-                padding=True, 
-                max_length=512
-            )
-            
-            with torch.no_grad():
-                outputs = self.models[model_idx](**inputs)
-                probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
-            
-            return probabilities[0].numpy()
-        except Exception as e:
-            print(f"Error in model {model_idx}: {e}")
-            return None
-    
-    def predict_ensemble(self, text):
-        """Predict sentiment using ensemble of all models"""
-        if not text.strip():
-            return "Please enter some text to analyze.", {}, {}
-        
-        individual_predictions = {}
-        all_probabilities = []
-        
-        # Get predictions from each model
-        for i, model_name in enumerate(self.model_names):
-            probs = self.predict_single_model(text, i)
-            if probs is not None:
-                all_probabilities.append(probs)
-                
-                # Individual model results
-                predicted_class = np.argmax(probs)
-                confidence = probs[predicted_class]
-                
-                model_short_name = model_name.split("/")[-1].replace("financial-sentiment-", "").title()
-                individual_predictions[f"{model_short_name}"] = {
-                    "Prediction": self.labels[predicted_class],
-                    "Confidence": f"{confidence:.1%}"
-                }
-        
-        if not all_probabilities:
-            return "Error: No models available for prediction.", {}, {}
-        
-        # Ensemble prediction (average probabilities)
-        ensemble_probs = np.mean(all_probabilities, axis=0)
-        ensemble_prediction = np.argmax(ensemble_probs)
-        ensemble_confidence = ensemble_probs[ensemble_prediction]
-        
-        # Create probability distribution for visualization
-        prob_dict = {}
-        for i, label in enumerate(self.labels):
-            prob_dict[label] = float(ensemble_probs[i])
-        
-        # Result summary
-        result_text = f"""
-## 🎯 Ensemble Prediction: **{self.labels[ensemble_prediction]}**
-**Confidence:** {ensemble_confidence:.1%}
-
-### 📊 Probability Distribution:
-- 📉 Bearish: {ensemble_probs[0]:.1%}
-- ➡️ Neutral: {ensemble_probs[1]:.1%}  
-- 📈 Bullish: {ensemble_probs[2]:.1%}
-
-### 🤖 Individual Model Results:
-"""
-        
-        for model_name, result in individual_predictions.items():
-            result_text += f"- **{model_name}**: {result['Prediction']} ({result['Confidence']})\n"
-        
-        return result_text, prob_dict, individual_predictions
-
-# Initialize the ensemble
-ensemble = FinancialSentimentEnsemble()
-
-def analyze_sentiment(text):
-    """Main function for Gradio interface"""
-    return ensemble.predict_ensemble(text)
-
-# Example texts for demonstration
-examples = [
-    "The stock market is showing strong bullish momentum with record highs across major indices.",
-    "Company earnings fell short of expectations, leading to a significant drop in share price.",
-    "The Federal Reserve maintained interest rates, keeping market conditions stable.",
-    "Tesla's innovative battery technology could revolutionize the automotive industry.",
-    "Rising inflation concerns are creating uncertainty in the financial markets.",
-    "The merger announcement sent both companies' stock prices soaring.",
-    "Quarterly results were mixed, with some sectors outperforming while others lagged."
-]
-
-# Create Gradio interface
-with gr.Blocks(
-    theme=gr.themes.Soft(),
-    title="Financial Sentiment Analysis Ensemble",
-    css="""
-    .gradio-container {
-        max-width: 1200px !important;
-    }
-    .main-header {
-        text-align: center;
-        margin-bottom: 2rem;
-    }
-    .model-info {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        padding: 1rem;
-        border-radius: 10px;
-        margin: 1rem 0;
-    }
-    """
-) as demo:
-    
-    gr.HTML("""
-    <div class="main-header">
-        <h1>🚀 Financial Sentiment Analysis Ensemble</h1>
-        <p>Advanced AI-powered sentiment analysis for financial texts using an ensemble of 3 fine-tuned models</p>
-    </div>
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            text_input = gr.Textbox(
-                label="📝 Enter Financial Text",
-                placeholder="Type or paste financial news, social media posts, or market commentary here...",
-                lines=4,
-                max_lines=10
-            )
-            
-            analyze_btn = gr.Button("🔍 Analyze Sentiment", variant="primary", size="lg")
-            
-            gr.Examples(
-                examples=examples,
-                inputs=text_input,
-                label="💡 Try these examples:"
-            )
-        
-        with gr.Column(scale=3):
-            result_output = gr.Markdown(label="📊 Analysis Results")
-            
-            with gr.Row():
-                prob_plot = gr.BarPlot(
-                    x="Sentiment",
-                    y="Probability", 
-                    title="Ensemble Probability Distribution",
-                    x_title="Sentiment Categories",
-                    y_title="Probability",
-                    width=400,
-                    height=300
-                )
-                
-                individual_results = gr.JSON(
-                    label="🤖 Individual Model Predictions",
-                    visible=True
-                )
-    
-    # Model Information
-    gr.HTML("""
-    <div class="model-info">
-        <h3>🧠 Ensemble Models:</h3>
-        <ul>
-            <li><strong>DistilBERT Model:</strong> Fast and efficient, optimized for real-time analysis</li>
-            <li><strong>BERT-Large Model:</strong> High accuracy with deep contextual understanding</li>
-            <li><strong>Improved Model:</strong> Enhanced with advanced training techniques</li>
-        </ul>
-        <p><strong>Ensemble Accuracy:</strong> 79.7% | <strong>Categories:</strong> Bearish 📉, Neutral ➡️, Bullish 📈</p>
-    </div>
-    """)
-    
-    # Event handlers
-    analyze_btn.click(
-        fn=analyze_sentiment,
-        inputs=text_input,
-        outputs=[result_output, prob_plot, individual_results]
-    )
-    
-    text_input.submit(
-        fn=analyze_sentiment,
-        inputs=text_input,
-        outputs=[result_output, prob_plot, individual_results]
-    )
-
-# Launch the app
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+#!/usr/bin/env python3
+"""
+Financial Sentiment Analysis - Enhanced Ensemble Gradio Demo for Hugging Face Space
+3-Model Ensemble System with Rule Engine
+"""
+
+import gradio as gr
+import torch
+import numpy as np
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import logging
+import re
+from typing import Dict, List, Tuple
+
+# Logging setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class SentimentRuleEngine:
+    """Rule-based post-processing for sentiment analysis"""
+    
+    def __init__(self):
+        # Strong bullish keywords with weights
+        self.bullish_keywords = {
+            'soaring': 0.9, 'skyrocketing': 0.9, 'surging': 0.9, 'exploding': 0.9,
+            'excellent': 0.8, 'outstanding': 0.8, 'exceptional': 0.8, 'amazing': 0.8,
+            'breakthrough': 0.8, 'revolutionary': 0.8, 'record-breaking': 0.9,
+            'all-time high': 0.9, 'new high': 0.8, 'moon': 0.8, 'rocket': 0.8,
+            'mooning': 0.9, 'rocketing': 0.8, 'booming': 0.7, 'thriving': 0.7,
+            'up 10%': 0.8, 'up 15%': 0.9, 'up 20%': 0.9, 'gained 10%': 0.8,
+            'rose 15%': 0.8, 'jumped 20%': 0.9, 'spiked': 0.8, 'surged': 0.8,
+            'rising': 0.6, 'climbing': 0.6, 'gaining': 0.6, 'growing': 0.6,
+            'strong': 0.5, 'solid': 0.5, 'robust': 0.5, 'healthy': 0.5,
+            'positive': 0.4, 'optimistic': 0.5, 'bullish': 0.8, 'rally': 0.7,
+            'beat': 0.7, 'exceeded': 0.7, 'outperformed': 0.7, 'success': 0.6,
+            'profit': 0.3, 'earnings': 0.2, 'revenue': 0.2, 'growth': 0.5
+        }
+        
+        # Strong bearish keywords with weights
+        self.bearish_keywords = {
+            'crashing': 0.9, 'plummeting': 0.9, 'collapsing': 0.9, 'tanking': 0.9,
+            'disaster': 0.8, 'terrible': 0.8, 'awful': 0.8, 'horrible': 0.8,
+            'crisis': 0.7, 'recession': 0.8, 'bankruptcy': 0.9, 'failed': 0.7,
+            'down 10%': 0.8, 'down 15%': 0.9, 'down 20%': 0.9, 'lost 10%': 0.8,
+            'fell 15%': 0.8, 'dropped 20%': 0.9, 'plunged': 0.8, 'tumbled': 0.7,
+            'falling': 0.6, 'declining': 0.6, 'dropping': 0.6, 'losing': 0.6,
+            'weak': 0.5, 'poor': 0.5, 'bad': 0.4, 'negative': 0.4,
+            'bearish': 0.8, 'selloff': 0.7, 'sell-off': 0.7, 'correction': 0.6,
+            'missed': 0.6, 'disappointed': 0.6, 'concerns': 0.4, 'worried': 0.5
+        }
+        
+        # Neutral keywords that should reduce extreme predictions
+        self.neutral_keywords = {
+            'mixed': 0.7, 'uncertain': 0.6, 'unclear': 0.6, 'sideways': 0.8,
+            'flat': 0.7, 'stable': 0.5, 'unchanged': 0.8, 'waiting': 0.6,
+            'consolidating': 0.7, 'range-bound': 0.8, 'choppy': 0.7
+        }
+    
+    def extract_keywords(self, text: str) -> Dict[str, float]:
+        """Extract sentiment keywords and their weights from text"""
+        text_lower = text.lower()
+        found_keywords = {'bullish': [], 'bearish': [], 'neutral': []}
+        
+        # Check for bullish keywords
+        for keyword, weight in self.bullish_keywords.items():
+            if keyword in text_lower:
+                found_keywords['bullish'].append((keyword, weight))
+        
+        # Check for bearish keywords  
+        for keyword, weight in self.bearish_keywords.items():
+            if keyword in text_lower:
+                found_keywords['bearish'].append((keyword, weight))
+        
+        # Check for neutral keywords
+        for keyword, weight in self.neutral_keywords.items():
+            if keyword in text_lower:
+                found_keywords['neutral'].append((keyword, weight))
+        
+        return found_keywords
+    
+    def apply_rules(self, text: str, model_probabilities: np.ndarray, 
+                   confidence_threshold: float = 0.7) -> Tuple[np.ndarray, str]:
+        """Apply rule-based post-processing to model predictions"""
+        
+        original_probs = model_probabilities.copy()
+        adjusted_probs = model_probabilities.copy()
+        
+        # Extract keywords
+        keywords = self.extract_keywords(text)
+        
+        # Calculate keyword scores
+        bullish_score = sum(weight for _, weight in keywords['bullish'])
+        bearish_score = sum(weight for _, weight in keywords['bearish']) 
+        neutral_score = sum(weight for _, weight in keywords['neutral'])
+        
+        explanation_parts = []
+        
+        # Apply adjustments based on keyword scores
+        if bullish_score > 0.5:
+            # Boost bullish probability
+            boost = min(0.3, bullish_score * 0.2)
+            adjusted_probs[2] += boost  # Bullish
+            adjusted_probs[0] = max(0.05, adjusted_probs[0] - boost/2)  # Bearish
+            adjusted_probs[1] = max(0.05, adjusted_probs[1] - boost/2)  # Neutral
+            explanation_parts.append(f"Bullish keywords detected (score: {bullish_score:.2f})")
+        
+        if bearish_score > 0.5:
+            # Boost bearish probability
+            boost = min(0.3, bearish_score * 0.2)
+            adjusted_probs[0] += boost  # Bearish
+            adjusted_probs[2] = max(0.05, adjusted_probs[2] - boost/2)  # Bullish
+            adjusted_probs[1] = max(0.05, adjusted_probs[1] - boost/2)  # Neutral
+            explanation_parts.append(f"Bearish keywords detected (score: {bearish_score:.2f})")
+        
+        if neutral_score > 0.5:
+            # Boost neutral probability
+            boost = min(0.2, neutral_score * 0.15)
+            adjusted_probs[1] += boost  # Neutral
+            adjusted_probs[0] = max(0.05, adjusted_probs[0] - boost/2)  # Bearish
+            adjusted_probs[2] = max(0.05, adjusted_probs[2] - boost/2)  # Bullish
+            explanation_parts.append(f"Neutral keywords detected (score: {neutral_score:.2f})")
+        
+        # Normalize probabilities
+        adjusted_probs = adjusted_probs / np.sum(adjusted_probs)
+        
+        # Create explanation
+        if explanation_parts:
+            explanation = "Applied: " + ", ".join(explanation_parts)
+        else:
+            explanation = "No significant keywords detected"
+        
+        return adjusted_probs, explanation
+
+# Initialize rule engine
+rule_engine = SentimentRuleEngine()
+
+class FinancialSentimentEnsemble:
+    """Ensemble model for financial sentiment analysis using Hugging Face models"""
+    
+    def __init__(self):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.models = {}
+        self.tokenizers = {}
+        self.label_names = ["Bearish 📉", "Neutral ⚖️", "Bullish 📈"]
+        
+        # Hugging Face model configurations
+        self.model_configs = {
+            "distilbert": {
+                "name": "DistilBERT (Fast)",
+                "repo_id": "codealchemist01/financial-sentiment-distilbert",
+                "description": "Fast and efficient model"
+            },
+            "bert_large": {
+                "name": "BERT-Large (Advanced)", 
+                "repo_id": "codealchemist01/financial-sentiment-bert-large",
+                "description": "Most advanced model"
+            },
+            "improved": {
+                "name": "Improved Model",
+                "repo_id": "codealchemist01/financial-sentiment-improved", 
+                "description": "Enhanced model with advanced training"
+            }
+        }
+        
+        # Ensemble weights for different combinations
+        self.ensemble_weights = {
+            "smart_ensemble": {"distilbert": 0.3, "bert_large": 0.7},
+            "all_models": {"distilbert": 0.2, "improved": 0.3, "bert_large": 0.5}
+        }
+        
+        self.load_models()
+    
+    def load_models(self):
+        """Load models from Hugging Face Hub"""
+        loaded_models = []
+        
+        for model_key, config in self.model_configs.items():
+            try:
+                logger.info(f"Loading {config['name']} from {config['repo_id']}")
+                
+                tokenizer = AutoTokenizer.from_pretrained(config["repo_id"])
+                model = AutoModelForSequenceClassification.from_pretrained(config["repo_id"])
+                model.to(self.device)
+                model.eval()
+                
+                self.tokenizers[model_key] = tokenizer
+                self.models[model_key] = model
+                loaded_models.append(config["name"])
+                
+                logger.info(f"✅ {config['name']} loaded successfully")
+                
+            except Exception as e:
+                logger.error(f"❌ Error loading {config['name']}: {e}")
+        
+        logger.info(f"🎯 Total loaded models: {len(loaded_models)}")
+        return loaded_models
+    
+    def predict_single_model(self, text, model_key):
+        """Get prediction from a single model"""
+        if model_key not in self.models:
+            return None, f"Model {model_key} not available"
+        
+        try:
+            tokenizer = self.tokenizers[model_key]
+            model = self.models[model_key]
+            
+            inputs = tokenizer(
+                text,
+                return_tensors="pt",
+                truncation=True,
+                padding=True,
+                max_length=512
+            )
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            
+            with torch.no_grad():
+                outputs = model(**inputs)
+                probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+                probabilities = probabilities.cpu().numpy()[0]
+            
+            return probabilities, None
+            
+        except Exception as e:
+            return None, f"Error in {model_key}: {str(e)}"
+    
+    def predict_ensemble(self, text, ensemble_type="smart_ensemble", use_rules=True):
+        """Make ensemble prediction"""
+        if not text.strip():
+            return "Please enter some text to analyze.", {}, ""
+        
+        try:
+            # Determine which models to use
+            if ensemble_type == "smart_ensemble":
+                weights = self.ensemble_weights["smart_ensemble"]
+                models_to_use = ["distilbert", "bert_large"]
+            elif ensemble_type == "all_models":
+                weights = self.ensemble_weights["all_models"] 
+                models_to_use = ["distilbert", "improved", "bert_large"]
+            else:
+                # Single model prediction
+                models_to_use = [ensemble_type]
+                weights = {ensemble_type: 1.0}
+            
+            # Get predictions from each model
+            ensemble_probabilities = np.zeros(3)
+            total_weight = 0
+            model_predictions = {}
+            model_details = []
+            
+            for model_key in models_to_use:
+                if model_key in self.models:
+                    probabilities, error = self.predict_single_model(text, model_key)
+                    if probabilities is not None:
+                        weight = weights.get(model_key, 1.0)
+                        ensemble_probabilities += probabilities * weight
+                        total_weight += weight
+                        
+                        # Store individual results
+                        predicted_class = np.argmax(probabilities)
+                        confidence = probabilities[predicted_class]
+                        model_predictions[model_key] = {
+                            "prediction": self.label_names[predicted_class],
+                            "confidence": float(confidence),
+                            "probabilities": probabilities.tolist()
+                        }
+                        
+                        model_details.append(
+                            f"**{self.model_configs[model_key]['name']}:** "
+                            f"{self.label_names[predicted_class]} ({confidence:.2%})"
+                        )
+            
+            if total_weight == 0:
+                return "No models available for prediction.", {}, ""
+            
+            # Normalize ensemble probabilities
+            ensemble_probabilities = ensemble_probabilities / total_weight
+            
+            # Apply rule-based post-processing if enabled
+            rule_explanation = ""
+            if use_rules:
+                ensemble_probabilities, rule_explanation = rule_engine.apply_rules(
+                    text, ensemble_probabilities, confidence_threshold=0.7
+                )
+            
+            # Get final prediction
+            predicted_class = np.argmax(ensemble_probabilities)
+            confidence = ensemble_probabilities[predicted_class]
+            
+            # Create detailed results
+            if len(models_to_use) > 1:
+                result_text = f"**🎯 Ensemble Prediction:** {self.label_names[predicted_class]}\\n"
+                result_text += f"**🔥 Ensemble Confidence:** {confidence:.2%}\\n\\n"
+                
+                result_text += "**🤖 Individual Model Results:**\\n"
+                for detail in model_details:
+                    result_text += f"- {detail}\\n"
+                result_text += "\\n"
+            else:
+                result_text = f"**🎯 Prediction:** {self.label_names[predicted_class]}\\n"
+                result_text += f"**🔥 Confidence:** {confidence:.2%}\\n\\n"
+            
+            # Show rule engine effects if applied
+            if use_rules and rule_explanation:
+                result_text += f"**🤖 Rule Engine:** {rule_explanation}\\n\\n"
+            
+            result_text += "**📊 Final Probabilities:**\\n"
+            
+            # Create probability dictionary for gradio
+            prob_dict = {}
+            for i, (label, prob) in enumerate(zip(self.label_names, ensemble_probabilities)):
+                prob_dict[label] = float(prob)
+                result_text += f"- {label}: {prob:.2%}\\n"
+            
+            # Create model comparison details
+            comparison_details = ""
+            if len(model_predictions) > 1:
+                comparison_details = "**🔍 Model Comparison:**\\n"
+                for model_key, pred_data in model_predictions.items():
+                    comparison_details += f"\\n**{self.model_configs[model_key]['name']}:**\\n"
+                    for i, (label, prob) in enumerate(zip(self.label_names, pred_data['probabilities'])):
+                        comparison_details += f"  - {label}: {prob:.2%}\\n"
+            
+            return result_text, prob_dict, comparison_details
+            
+        except Exception as e:
+            logger.error(f"Prediction error: {e}")
+            return f"Error during prediction: {str(e)}", {}, ""
+
+# Initialize ensemble model
+try:
+    ensemble = FinancialSentimentEnsemble()
+    available_models = list(ensemble.models.keys())
+    gpu_info = f"🚀 **Models loaded:** {len(available_models)} models on {ensemble.device}"
+except Exception as e:
+    gpu_info = f"❌ **Error loading models:** {str(e)}"
+    ensemble = None
+    available_models = []
+
+def analyze_sentiment(text, model_selection, use_rules):
+    """Main analysis function"""
+    if ensemble is None:
+        return "Models not loaded. Please check the error above.", {}, ""
+    
+    return ensemble.predict_ensemble(text, model_selection, use_rules)
+
+# Example texts for testing
+examples = [
+    ["Tesla stock is soaring after excellent Q3 earnings report! 🚀", "smart_ensemble", True],
+    ["The market is showing mixed signals today, uncertain direction.", "smart_ensemble", True], 
+    ["Major selloff expected as inflation concerns grow. Bearish outlook.", "all_models", True],
+    ["Apple announces new iPhone with revolutionary features!", "distilbert", False],
+    ["Economic indicators suggest potential recession ahead.", "bert_large", True],
+    ["Crypto market rebounds strongly after recent dip.", "smart_ensemble", True]
+]
+
+# Create Gradio interface
+with gr.Blocks(
+    title="Financial Sentiment Analysis - Ensemble System",
+    theme=gr.themes.Soft(),
+    css="""
+    .gradio-container {
+        max-width: 1000px !important;
+        margin: auto !important;
+    }
+    .header {
+        text-align: center;
+        padding: 20px;
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+    .model-info {
+        background-color: #f8f9fa;
+        padding: 15px;
+        border-radius: 8px;
+        margin: 10px 0;
+    }
+    """
+) as demo:
+    
+    gr.HTML(f"""
+    <div class="header">
+        <h1>📈 Financial Sentiment Analysis Ensemble</h1>
+        <h3>Advanced AI-powered sentiment analysis for financial texts using an ensemble of 3 fine-tuned models</h3>
+        <p>{gpu_info}</p>
+    </div>
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            text_input = gr.Textbox(
+                label="📝 Enter Financial Text to Analyze",
+                placeholder="Enter financial news, tweets, or market commentary...",
+                lines=4
+            )
+            
+            with gr.Row():
+                model_selection = gr.Dropdown(
+                    choices=[
+                        ("🧠 Smart Ensemble (Recommended)", "smart_ensemble"),
+                        ("🎯 All Models Ensemble", "all_models"),
+                        ("⚡ DistilBERT (Fast)", "distilbert"),
+                        ("🔥 BERT-Large (Advanced)", "bert_large"),
+                        ("🚀 Improved Model", "improved")
+                    ],
+                    value="smart_ensemble",
+                    label="🤖 Model Selection"
+                )
+                
+                use_rules = gr.Checkbox(
+                    label="🤖 Rule-Based Enhancement",
+                    value=True,
+                    info="Apply keyword-based post-processing"
+                )
+            
+            analyze_btn = gr.Button("🔍 Analyze Sentiment", variant="primary", size="lg")
+        
+        with gr.Column(scale=2):
+            result_output = gr.Textbox(
+                label="📊 Analysis Results",
+                lines=12,
+                interactive=False
+            )
+            
+            prob_output = gr.Label(
+                label="📈 Probability Distribution",
+                num_top_classes=3
+            )
+    
+    with gr.Row():
+        comparison_output = gr.Textbox(
+            label="🔍 Model Comparison Details",
+            lines=8,
+            interactive=False,
+            visible=True
+        )
+    
+    # Event handlers
+    analyze_btn.click(
+        fn=analyze_sentiment,
+        inputs=[text_input, model_selection, use_rules],
+        outputs=[result_output, prob_output, comparison_output]
+    )
+    
+    # Examples section
+    gr.Examples(
+        examples=examples,
+        inputs=[text_input, model_selection, use_rules],
+        outputs=[result_output, prob_output, comparison_output],
+        fn=analyze_sentiment,
+        cache_examples=False,
+        label="💡 Try these examples:"
+    )
+    
+    # Model information
+    gr.HTML("""
+    <div class="model-info">
+        <h4>🤖 Ensemble System Information</h4>
+        <ul>
+            <li><strong>🧠 Smart Ensemble:</strong> DistilBERT + BERT-Large (Best balance of speed and accuracy)</li>
+            <li><strong>🎯 All Models:</strong> DistilBERT + Improved + BERT-Large (Maximum consensus)</li>
+            <li><strong>⚡ DistilBERT:</strong> Fast and efficient model optimized for real-time analysis</li>
+            <li><strong>🔥 BERT-Large:</strong> Most advanced model with deep contextual understanding</li>
+            <li><strong>🚀 Improved Model:</strong> Enhanced with advanced training techniques</li>
+        </ul>
+        <p><em>💡 Tip: Smart Ensemble provides the best balance of accuracy and performance!</em></p>
+        <p><em>🤖 Rule Engine: Applies keyword-based post-processing to improve accuracy on financial texts</em></p>
+    </div>
+    """)
+
+if __name__ == "__main__":
+    demo.launch()