Update app.py

app.py

@@ -1,463 +1,295 @@
 import gradio as gr
+import torch
 import pickle
 import pandas as pd
 import os
+import io
 
-# Recreate the bias corrector classes to match the saved model
-class BiasCorrector:
-    def __init__(self, target_distribution=None):
-        """Initialize bias corrector with target distribution"""
-        if target_distribution is None:
-            self.target_distribution = {'negative': 0.33, 'neutral': 0.34, 'positive': 0.33}
-        else:
-            self.target_distribution = target_distribution
-        
-        self.confidence_threshold = 0.7
-        self.bias_correction_factor = 0.15
-        
-    def correct_prediction(self, prediction_result):
-        """Apply bias correction to a prediction result"""
-        if not isinstance(prediction_result, dict):
-            return prediction_result
-            
-        if 'scores' not in prediction_result:
-            return prediction_result
-            
-        scores = prediction_result['scores']
-        original_sentiment = prediction_result['sentiment']
-        confidence = prediction_result['confidence']
-        
-        if confidence < self.confidence_threshold:
-            corrected_scores = scores.copy()
-            
-            if original_sentiment == 'negative' and confidence < 0.6:
-                corrected_scores['positive'] += self.bias_correction_factor
-                corrected_scores['neutral'] += self.bias_correction_factor * 0.5
-                corrected_scores['negative'] -= self.bias_correction_factor * 1.5
-            elif original_sentiment == 'positive' and confidence < 0.5:
-                corrected_scores['positive'] += self.bias_correction_factor * 0.5
-            
-            total = sum(corrected_scores.values())
-            corrected_scores = {k: v/total for k, v in corrected_scores.items()}
-            
-            new_sentiment = max(corrected_scores, key=corrected_scores.get)
-            new_confidence = corrected_scores[new_sentiment]
-            
-            return {
-                'sentiment': new_sentiment,
-                'confidence': new_confidence,
-                'scores': corrected_scores,
-                'original_sentiment': original_sentiment,
-                'bias_corrected': True
-            }
-        
-        prediction_result['bias_corrected'] = False
-        return prediction_result
+# Global variables
+loaded_pipeline = None
+model_device = 'cpu'  # Force CPU for Hugging Face Spaces
 
-class SimpleSentimentClassifier:
-    def __init__(self):
-        self.positive_words = [
-            'amazing', 'excellent', 'fantastic', 'great', 'love', 'best', 'perfect',
-            'outstanding', 'wonderful', 'awesome', 'brilliant', 'superb', 'magnificent',
-            'good', 'nice', 'happy', 'satisfied', 'recommend', 'pleased'
-        ]
+def load_model():
+    """Load the BERT sentiment model from pickle"""
+    global loaded_pipeline
+    
+    print(f"🖥️ Using device: {model_device}")
+    
+    try:
+        model_file = 'sentiment_pipeline.pkl'
         
-        self.negative_words = [
-            'terrible', 'awful', 'horrible', 'worst', 'hate', 'disappointed', 'bad',
-            'poor', 'disgusting', 'useless', 'waste', 'pathetic', 'ridiculous',
-            'annoying', 'frustrating', 'disgusted', 'angry', 'upset'
-        ]
+        if not os.path.exists(model_file):
+            print(f"❌ Model file not found: {model_file}")
+            return False
         
-        self.bias_corrector = BiasCorrector()
-    
-    def predict(self, text):
-        """Simple rule-based prediction with bias correction"""
-        text_lower = text.lower()
+        print(f"📦 Loading BERT model from {model_file}...")
         
-        positive_score = sum(1 for word in self.positive_words if word in text_lower)
-        negative_score = sum(1 for word in self.negative_words if word in text_lower)
+        # Custom unpickler for CPU compatibility
+        class CPUUnpickler(pickle.Unpickler):
+            def find_class(self, module, name):
+                if module == 'torch.storage' and name == '_load_from_bytes':
+                    return lambda b: torch.load(io.BytesIO(b), map_location='cpu')
+                else:
+                    return super().find_class(module, name)
         
-        total_words = len(text.split())
-        pos_ratio = positive_score / max(total_words, 1)
-        neg_ratio = negative_score / max(total_words, 1)
+        with open(model_file, 'rb') as f:
+            loaded_pipeline = pickle.load(f)
         
-        if pos_ratio > neg_ratio and positive_score > 0:
-            sentiment = 'positive'
-            confidence = min(0.8, 0.5 + pos_ratio)
-        elif neg_ratio > pos_ratio and negative_score > 0:
-            sentiment = 'negative'
-            confidence = min(0.8, 0.5 + neg_ratio)
-        else:
-            sentiment = 'neutral'
-            confidence = 0.6
+        # Move model to CPU
+        if 'model' in loaded_pipeline:
+            loaded_pipeline['model'] = loaded_pipeline['model'].to('cpu')
+            loaded_pipeline['model'].eval()
         
-        if sentiment == 'positive':
-            scores = {'positive': confidence, 'neutral': (1-confidence)*0.7, 'negative': (1-confidence)*0.3}
-        elif sentiment == 'negative':
-            scores = {'negative': confidence, 'neutral': (1-confidence)*0.7, 'positive': (1-confidence)*0.3}
-        else:
-            scores = {'neutral': confidence, 'positive': (1-confidence)*0.5, 'negative': (1-confidence)*0.5}
+        print(f"✅ Successfully loaded BERT model")
         
-        result = {
-            'sentiment': sentiment,
-            'confidence': confidence,
-            'scores': scores
-        }
+        if 'best_val_accuracy' in loaded_pipeline:
+            print(f"🎯 Validation Accuracy: {loaded_pipeline['best_val_accuracy']:.4f}")
         
-        return self.bias_corrector.correct_prediction(result)
-
-# Global variables for model components
-loaded_model = None
-model_device = 'cpu'  # Force CPU for compatibility
+        return True
+            
+    except Exception as e:
+        print(f"❌ Loading failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
 
-def load_trained_model():
-    """Load the bias-corrected sentiment model"""
-    global loaded_model
+def predict_sentiment(text):
+    """Predict sentiment using BERT model"""
     
-    print(f"🖥️ Using device: {model_device}")
+    if loaded_pipeline is None:
+        return {
+            'sentiment': 'error',
+            'confidence': 0.0,
+            'scores': {'negative': 0.0, 'neutral': 0.0, 'positive': 0.0},
+            'error': 'Model not loaded'
+        }
     
     try:
-        # Try loading the bias-corrected model
-        model_files = ['sentiment_pipeline.pkl', 'sentiment_pipeline_improved.pkl']
+        model = loaded_pipeline['model']
+        tokenizer = loaded_pipeline['tokenizer']
+        max_length = loaded_pipeline.get('training_config', {}).get('max_length', 128)
+        
+        # Tokenize
+        inputs = tokenizer(
+            text,
+            return_tensors='pt',
+            truncation=True,
+            padding=True,
+            max_length=max_length
+        )
         
-        for model_file in model_files:
-            if os.path.exists(model_file):
-                print(f"📦 Loading model from {model_file}...")
-                
-                with open(model_file, 'rb') as f:
-                    pipeline = pickle.load(f)
-                    loaded_model = pipeline
-                
-                print(f"✅ Successfully loaded bias-corrected model from {model_file}")
-                
-                # Check model type
-                model_type = pipeline.get('model_type', 'unknown')
-                test_accuracy = pipeline.get('test_accuracy', 'unknown')
-                
-                print(f"📊 Model type: {model_type}")
-                print(f"🎯 Test accuracy: {test_accuracy}")
-                
-                return True
+        inputs = {k: v.to('cpu') for k, v in inputs.items()}
+        
+        # Predict
+        model.eval()
+        with torch.no_grad():
+            outputs = model(**inputs)
+            probabilities = torch.softmax(outputs.logits, dim=1)
+            prediction = torch.argmax(probabilities, dim=1).item()
+            confidence = probabilities.max().item()
+        
+        sentiment_names = ['negative', 'neutral', 'positive']
+        
+        return {
+            'sentiment': sentiment_names[prediction],
+            'confidence': confidence,
+            'scores': {
+                'negative': float(probabilities[0][0].item()),
+                'neutral': float(probabilities[0][1].item()),
+                'positive': float(probabilities[0][2].item())
+            }
+        }
         
-        print("❌ No model files found")
-        return False
-            
     except Exception as e:
-        print(f"❌ Model loading failed: {e}")
-        return False
+        print(f"Prediction error: {e}")
+        return {
+            'sentiment': 'error',
+            'confidence': 0.0,
+            'scores': {'negative': 0.0, 'neutral': 0.0, 'positive': 0.0},
+            'error': str(e)
+        }
 
-def predict_sentiment_with_details(text):
-    """Predict sentiment with bias correction and detailed output"""
+def analyze_sentiment(text):
+    """Analyze sentiment and return formatted results"""
     
-    # Check if model is loaded
-    if loaded_model is None:
+    if loaded_pipeline is None:
         return (
-            "❌ **ERROR: Model not loaded!**\n\nPlease check if model files are available.",
+            "❌ **Model not loaded!** Please upload sentiment_pipeline.pkl",
             pd.DataFrame(),
-            "Error: No model",
+            "Error",
             "Model not available"
         )
     
-    # Check if text is provided
     if not text or not text.strip():
         return (
-            "⚠️ **Please enter some text to analyze**",
+            "⚠️ **Please enter text**",
             pd.DataFrame(),
             "No input",
             "Enter text above"
         )
     
     try:
-        # Clean and prepare text
-        clean_text = text.strip()
-        print(f"🔍 Analyzing: {clean_text[:50]}{'...' if len(clean_text) > 50 else ''}")
+        result = predict_sentiment(text.strip())
         
-        # Get prediction using the loaded model
-        predict_function = loaded_model.get('predict')
-        if predict_function:
-            result = predict_function(clean_text)
-        else:
-            # Fallback if predict function not available
-            model_obj = loaded_model.get('model')
-            if hasattr(model_obj, 'predict'):
-                result = model_obj.predict(clean_text)
-            else:
-                raise Exception("No prediction function available")
+        if 'error' in result:
+            return (
+                f"❌ **Error:** {result['error']}",
+                pd.DataFrame(),
+                "Error",
+                f"Error: {result['error']}"
+            )
         
-        predicted_sentiment = result['sentiment']
+        sentiment = result['sentiment']
         confidence = result['confidence']
-        scores = result.get('scores', {})
-        
-        # Check if bias correction was applied
-        bias_corrected = result.get('bias_corrected', False)
-        original_sentiment = result.get('original_sentiment', predicted_sentiment)
+        scores = result['scores']
         
-        # Create confidence scores for visualization using DataFrame
-        confidence_data = pd.DataFrame({
+        # Create DataFrame for chart
+        chart_data = pd.DataFrame({
             'Sentiment': ['Negative', 'Neutral', 'Positive'],
-            'Confidence': [
-                scores.get('negative', 0),
-                scores.get('neutral', 0),
-                scores.get('positive', 0)
-            ]
+            'Confidence': [scores['negative'], scores['neutral'], scores['positive']]
         })
         
-        # Create detailed result message
-        emoji_map = {'negative': '😞', 'neutral': '😐', 'positive': '😊'}
-        emoji = emoji_map.get(predicted_sentiment, '🤔')
+        # Emoji mapping
+        emoji = {'negative': '😞', 'neutral': '😐', 'positive': '😊'}[sentiment]
         
-        # Add bias correction info
-        bias_info = ""
-        if bias_corrected:
-            bias_info = f"\n🔧 **Bias Correction Applied**\n   Original prediction: {original_sentiment.title()}\n   Adjusted to: {predicted_sentiment.title()}"
-        
-        result_message = f"""
-### {emoji} **{predicted_sentiment.title()}** Sentiment Detected
-
-**Confidence Score:** {confidence:.1%}
+        # Result message
+        message = f"""
+### {emoji} **{sentiment.title()}** Sentiment
 
-**Input Text:** *"{clean_text[:100]}{'...' if len(clean_text) > 100 else ''}"*
+**Confidence:** {confidence:.1%}
 
-**Analysis Details:**
-- **Negative:** {scores.get('negative', 0):.1%}
-- **Neutral:** {scores.get('neutral', 0):.1%}  
-- **Positive:** {scores.get('positive', 0):.1%}
+**Text:** *"{text[:100]}{'...' if len(text) > 100 else ''}"*
 
-{bias_info}
+**Scores:**
+- 😞 Negative: {scores['negative']:.1%}
+- 😐 Neutral: {scores['neutral']:.1%}  
+- 😊 Positive: {scores['positive']:.1%}
 
-**Model Status:** ✅ Prediction completed with bias correction enabled
+✅ Bias-corrected BERT model
         """
         
-        status_message = f"✅ Analysis complete - {predicted_sentiment.title()} sentiment detected with {confidence:.1%} confidence"
-        if bias_corrected:
-            status_message += " (bias corrected)"
-        
-        return result_message, confidence_data, predicted_sentiment.title(), status_message
+        return message, chart_data, sentiment.title(), f"✅ {sentiment.title()} ({confidence:.1%})"
         
     except Exception as e:
-        error_msg = f"❌ **Prediction Error:** {str(e)}\n\nPlease check the model and input text."
-        print(f"Prediction error: {e}")
-        return error_msg, pd.DataFrame(), "Error", f"Error: {str(e)}"
+        return (
+            f"❌ **Error:** {str(e)}",
+            pd.DataFrame(),
+            "Error",
+            f"Error: {str(e)}"
+        )
 
-def create_gradio_interface():
-    """Create enhanced Gradio interface with bias correction info"""
+# Create Gradio interface
+with gr.Blocks(title="BERT Sentiment Analyzer", theme=gr.themes.Soft()) as demo:
     
-    # Custom CSS for better styling
-    css = """
-    .model-status {
-        padding: 1rem;
-        border-radius: 8px;
-        margin-bottom: 1rem;
-        text-align: center;
-        font-weight: bold;
-    }
-    .status-success {
-        background-color: #d4edda;
-        color: #155724;
-        border: 1px solid #c3e6cb;
-    }
-    .status-error {
-        background-color: #f8d7da;
-        color: #721c24;
-        border: 1px solid #f5c6cb;
-    }
-    .bias-correction {
-        background-color: #fff3cd;
-        color: #856404;
-        border: 1px solid #ffeaa7;
-        padding: 0.5rem;
-        border-radius: 5px;
-        margin: 0.5rem 0;
-    }
-    """
+    gr.HTML("""
+    <div style="text-align: center; padding: 2rem; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 2rem;">
+        <h1>🤖 BERT Sentiment Analyzer</h1>
+        <p style="font-size: 1.2em;">Bias-Corrected Sentiment Classification</p>
+        <p>✅ Trained with balanced data • No negative bias</p>
+    </div>
+    """)
     
-    with gr.Blocks(css=css, title="BERT Sentiment Analyzer - Bias Corrected", theme=gr.themes.Soft()) as demo:
-        
-        # Header with model status
-        gr.HTML("""
-        <div style="text-align: center; padding: 2rem; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 2rem;">
-            <h1>🤖 BERT Sentiment Classification</h1>
-            <p>Advanced AI-powered sentiment analysis with bias correction</p>
-            <p><strong>🔧 Bias-Corrected Model - Fixed Negative Bias Issue</strong></p>
-            <p><strong>🌍 Ready for permanent deployment</strong></p>
-        </div>
-        """)
-        
-        # Model status indicator
-        model_status = gr.HTML()
-        
-        with gr.Row():
-            with gr.Column(scale=3):
-                gr.Markdown("### 📝 Enter Text for Sentiment Analysis")
-                
-                text_input = gr.Textbox(
-                    label="Input Text",
-                    placeholder="Enter your text here... (e.g., 'This product is amazing! Great quality and fast delivery.')",
-                    lines=6,
-                    max_lines=20,
-                    value=""
-                )
-                
-                with gr.Row():
-                    analyze_btn = gr.Button("🔍 Analyze Sentiment", variant="primary", size="lg")
-                    clear_btn = gr.Button("🗑️ Clear", size="sm")
-                
-                gr.Markdown("### 💡 Example Texts to Try (Test Bias Correction):")
-                examples = gr.Examples(
-                    examples=[
-                        # Positive examples
-                        ["This product exceeded all my expectations! Outstanding quality and excellent customer service."],
-                        ["Best purchase I've made this year! Highly recommend to everyone."],
-                        ["The delivery was fast and the packaging was perfect!"],
-                        
-                        # Negative examples
-                        ["I'm completely disappointed with this purchase. Poor quality and terrible customer support."],
-                        ["Absolutely horrible experience. Would never buy from this company again."],
-                        ["Customer service was unhelpful and rude."],
-                        
-                        # Neutral/ambiguous examples (test bias correction)
-                        ["The product is decent. It works as described but nothing extraordinary."],
-                        ["It's okay, good value for the price but could be improved."],
-                        ["Not bad, not great. Just acceptable."],
-                        
-                        # Edge cases (test bias correction)
-                        ["This is not bad at all"],  # Double negative
-                        ["Could be better"],  # Subtle negative
-                        ["Pretty good"],  # Subtle positive
-                    ],
-                    inputs=text_input,
-                    label=None
-                )
+    model_status = gr.HTML()
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            gr.Markdown("### 📝 Input Text")
             
-            with gr.Column(scale=2):
-                gr.Markdown("### 📊 Analysis Results")
-                
-                result_output = gr.Markdown(
-                    value="*Enter text and click 'Analyze Sentiment' to see results*"
-                )
-                
-                # DataFrame-based BarPlot for compatibility
-                confidence_plot = gr.BarPlot(
-                    x="Sentiment",
-                    y="Confidence",
-                    title="Confidence Scores by Sentiment Class",
-                    x_title="Sentiment",
-                    y_title="Confidence Score",
-                    width=500,
-                    height=300,
-                    container=True
-                )
-                
-                predicted_class = gr.Textbox(
-                    label="Predicted Sentiment Class",
-                    interactive=False,
-                    value=""
-                )
-                
-                status_display = gr.Textbox(
-                    label="Analysis Status",
-                    interactive=False,
-                    value="Ready for analysis"
-                )
-        
-        # Model Information Section
-        with gr.Accordion("🔍 Model Information & Bias Correction Details", open=False):
-            gr.Markdown(f"""
-            ### 🧠 Model Architecture
-            - **Base Model:** BERT-inspired with bias correction
-            - **Task:** Multi-class sentiment classification
-            - **Classes:** Negative 😞, Neutral 😐, Positive 😊
-            - **Device:** {model_device}
-            - **Bias Correction:** ✅ Enabled
+            text_input = gr.Textbox(
+                label="Enter text to analyze",
+                placeholder="Example: 'This product is amazing! Great quality and excellent service.'",
+                lines=6
+            )
             
-            ### 🔧 Bias Correction Features
-            - **Automatic Detection:** Identifies low-confidence predictions prone to bias
-            - **Dynamic Adjustment:** Adjusts prediction scores to reduce negative bias
-            - **Confidence Threshold:** Applies correction when confidence < 70%
-            - **Transparency:** Shows when bias correction is applied
+            with gr.Row():
+                analyze_btn = gr.Button("🔍 Analyze", variant="primary", size="lg")
+                clear_btn = gr.Button("🗑️ Clear", size="sm")
             
-            ### 📊 Training Configuration
-            - **Model Type:** Rule-based with bias correction
-            - **Bias Correction Factor:** 15% adjustment for low-confidence predictions
-            - **Test Accuracy:** 100% on bias test cases
-            - **Training Data:** Balanced customer feedback dataset
+            gr.Markdown("### 💡 Examples:")
+            gr.Examples(
+                examples=[
+                    ["This product is absolutely amazing! Best purchase ever!"],
+                    ["I love this so much! Outstanding quality!"],
+                    ["Excellent customer service and fast delivery!"],
+                    ["This is terrible! Worst product ever!"],
+                    ["Completely disappointed. Poor quality."],
+                    ["Awful experience. Would never buy again!"],
+                    ["The product is okay. Nothing special but works."],
+                    ["It's decent. Good value but could be better."],
+                    ["This is not bad at all"],
+                    ["Pretty good"],
+                ],
+                inputs=text_input
+            )
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 Results")
             
-            ### ⚙️ How Bias Correction Works
-            1. **Standard Prediction:** Model makes initial sentiment prediction
-            2. **Confidence Check:** System checks if confidence is below threshold
-            3. **Bias Detection:** Identifies potential negative bias in low-confidence cases
-            4. **Score Adjustment:** Adjusts sentiment scores to reduce bias
-            5. **Re-evaluation:** Provides corrected prediction with transparency
+            result_output = gr.Markdown("*Enter text to see results*")
             
-            ### 🚀 Usage Instructions
-            1. **Enter text** in the input box above
-            2. **Click 'Analyze Sentiment'** to get predictions
-            3. **View results** including confidence scores and bias correction info
-            4. **Try the examples** to see bias correction in action
-            5. **Look for 🔧 symbols** indicating bias correction was applied
+            confidence_plot = gr.BarPlot(
+                x="Sentiment",
+                y="Confidence",
+                title="Confidence Scores",
+                width=500,
+                height=300
+            )
             
-            ### 💡 What's Fixed
-            - ❌ **Before:** Model biased toward negative predictions
-            - ✅ **After:** Balanced predictions with automatic bias correction
-            - 🔧 **Feature:** Transparent bias correction with explanations
-            """)
-        
-        # Event handlers
-        def clear_inputs():
-            return "", "*Enter text to see analysis*", pd.DataFrame(), "", "Ready for analysis"
-        
-        def update_model_status():
-            if loaded_model is not None:
-                model_type = loaded_model.get('model_type', 'unknown')
-                test_accuracy = loaded_model.get('test_accuracy', 'unknown')
-                return f"""<div class="model-status status-success">✅ Bias-Corrected Model Loaded Successfully!<br>
-                Type: {model_type}<br>Test Accuracy: {test_accuracy}</div>"""
-            else:
-                return """<div class="model-status status-error">❌ Model Not Loaded</div>"""
-        
-        # Connect events
-        analyze_btn.click(
-            fn=predict_sentiment_with_details,
-            inputs=text_input,
-            outputs=[result_output, confidence_plot, predicted_class, status_display]
-        )
-        
-        clear_btn.click(
-            fn=clear_inputs,
-            outputs=[text_input, result_output, confidence_plot, predicted_class, status_display]
-        )
-        
-        # Update model status on load
-        demo.load(
-            fn=update_model_status,
-            outputs=model_status
-        )
+            predicted_class = gr.Textbox(label="Prediction", interactive=False)
+            status_display = gr.Textbox(label="Status", interactive=False, value="Ready")
+    
+    with gr.Accordion("ℹ️ Model Info", open=False):
+        gr.Markdown("""
+        ### 🧠 Model
+        - **Architecture:** BERT (bert-base-uncased)
+        - **Classes:** Negative 😞, Neutral 😐, Positive 😊
+        - **Training:** Balanced dataset with class weights
+        
+        ### 🔧 Features
+        - ✅ No negative bias
+        - ✅ Balanced training data
+        - ✅ Class-weighted loss
+        - ✅ CPU optimized
+        
+        ### 📊 Configuration
+        - Epochs: 4
+        - Learning Rate: 1e-5
+        - Batch Size: 16
+        - Max Length: 128 tokens
+        """)
     
-    return demo
+    def clear_all():
+        return "", "*Enter text*", pd.DataFrame(), "", "Ready"
+    
+    def update_status():
+        if loaded_pipeline:
+            val_acc = loaded_pipeline.get('best_val_accuracy', 'N/A')
+            return f"""<div style="padding: 1rem; background: #d4edda; color: #155724; border-radius: 8px; text-align: center;">
+            ✅ Model Loaded | Accuracy: {val_acc if isinstance(val_acc, str) else f'{val_acc:.2%}'}</div>"""
+        return """<div style="padding: 1rem; background: #f8d7da; color: #721c24; border-radius: 8px; text-align: center;">
+        ❌ Model Not Loaded</div>"""
+    
+    analyze_btn.click(
+        fn=analyze_sentiment,
+        inputs=text_input,
+        outputs=[result_output, confidence_plot, predicted_class, status_display]
+    )
+    
+    clear_btn.click(
+        fn=clear_all,
+        outputs=[text_input, result_output, confidence_plot, predicted_class, status_display]
+    )
+    
+    demo.load(fn=update_status, outputs=model_status)
 
-# Load model and launch interface
 if __name__ == "__main__":
-    print("🚀 Starting Bias-Corrected BERT Sentiment Analyzer...")
+    print("🚀 Starting BERT Sentiment Analyzer...")
     print("=" * 60)
     
-    # Load the model
-    model_loaded = load_trained_model()
-    
-    if model_loaded:
-        print("\n🎉 BIAS-CORRECTED MODEL READY FOR PREDICTIONS!")
-        print("✅ Creating Gradio interface...")
-        
-        # Create and launch interface
-        demo = create_gradio_interface()
-        
-        print("🌐 Launching web interface...")
-        print("📱 The interface will open automatically")
-        print("🔧 Bias correction enabled - negative bias issue fixed!")
-        print("=" * 60)
-        
-        # Launch the interface
+    if load_model():
+        print("\n✅ MODEL READY!")
+        print("🌐 Launching interface...")
         demo.launch()
     else:
-        print("\n❌ Model loading failed!")
-        print("💡 Please run the bias correction script first:")
-        print("   python create_bias_corrected_model.py")
+        print("\n❌ FAILED TO LOAD MODEL!")
+        print("📋 Ensure sentiment_pipeline.pkl exists")