Create app.py

app.py

@@ -0,0 +1,340 @@
+import gradio as gr
+import torch
+import pickle
+import pandas as pd
+from transformers import BertTokenizer, BertForSequenceClassification
+import numpy as np
+import os
+
+# Global variables for model components
+loaded_model = None
+loaded_tokenizer = None
+model_device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+def load_trained_model():
+    """Load the trained BERT model with comprehensive error handling"""
+    global loaded_model, loaded_tokenizer
+    
+    print(f"🖥️ Using device: {model_device}")
+    
+    try:
+        # Method 1: Try loading from pickle (most reliable)
+        if os.path.exists('sentiment_pipeline.pkl'):
+            print("📦 Loading model from pickle file...")
+            with open('sentiment_pipeline.pkl', 'rb') as f:
+                pipeline = pickle.load(f)
+                loaded_model = pipeline['model']
+                loaded_tokenizer = pipeline['tokenizer']
+            print("✅ Successfully loaded model from sentiment_pipeline.pkl")
+            
+        # Method 2: Try loading from HuggingFace format
+        elif os.path.exists('bert_sentiment_model'):
+            print("🤗 Loading model from HuggingFace format...")
+            loaded_model = BertForSequenceClassification.from_pretrained('bert_sentiment_model')
+            loaded_tokenizer = BertTokenizer.from_pretrained('bert_sentiment_model')
+            print("✅ Successfully loaded model from bert_sentiment_model/")
+            
+        else:
+            # Method 3: Load pre-trained model if no fine-tuned model exists
+            print("⚠️ No fine-tuned model found, loading base BERT model...")
+            loaded_model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=3)
+            loaded_tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+            print("✅ Loaded base BERT model (not fine-tuned)")
+            
+        # Verify model is loaded and move to device
+        if loaded_model is not None and loaded_tokenizer is not None:
+            loaded_model.eval()
+            loaded_model.to(model_device)
+            
+            # Test the model with a simple prediction
+            test_input = "This is a test"
+            inputs = loaded_tokenizer(test_input, return_tensors='pt', truncation=True, padding=True, max_length=128).to(model_device)
+            with torch.no_grad():
+                outputs = loaded_model(**inputs)
+                probabilities = torch.softmax(outputs.logits, dim=1)
+            print("✅ Model test prediction successful!")
+            print(f"📊 Model parameters: {sum(p.numel() for p in loaded_model.parameters()):,}")
+            return True
+        else:
+            print("❌ Model or tokenizer is None after loading")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Model loading failed: {e}")
+        return False
+
+def predict_sentiment_with_details(text):
+    """Predict sentiment with detailed output and error handling"""
+    
+    # Check if model is loaded
+    if loaded_model is None or loaded_tokenizer is None:
+        return (
+            "❌ **ERROR: Model not loaded!**\n\nPlease check if model files are available.",
+            pd.DataFrame(),
+            "Error: No model",
+            "Model not available"
+        )
+    
+    # Check if text is provided
+    if not text or not text.strip():
+        return (
+            "⚠️ **Please enter some text to analyze**",
+            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 ''}")
+        
+        # Tokenize input
+        inputs = loaded_tokenizer(
+            clean_text, 
+            return_tensors='pt', 
+            truncation=True, 
+            padding=True, 
+            max_length=128
+        ).to(model_device)
+        
+        # Get prediction
+        with torch.no_grad():
+            outputs = loaded_model(**inputs)
+            probabilities = torch.softmax(outputs.logits, dim=1)
+            prediction = torch.argmax(probabilities, dim=1).item()
+            confidence = probabilities.max().item()
+        
+        # Map labels
+        label_mapping = {0: 'Negative', 1: 'Neutral', 2: 'Positive'}
+        predicted_sentiment = label_mapping[prediction]
+        
+        # Create confidence scores for visualization using DataFrame
+        confidence_data = pd.DataFrame({
+            'Sentiment': ['Negative', 'Neutral', 'Positive'],
+            'Confidence': [
+                float(probabilities[0][0].item()),
+                float(probabilities[0][1].item()),
+                float(probabilities[0][2].item())
+            ]
+        })
+        
+        # Create detailed result message
+        emoji_map = {'Negative': '😞', 'Neutral': '😐', 'Positive': '😊'}
+        emoji = emoji_map[predicted_sentiment]
+        
+        result_message = f"""
+### {emoji} **{predicted_sentiment}** Sentiment Detected
+
+**Confidence Score:** {confidence:.1%}
+
+**Input Text:** *"{clean_text[:100]}{'...' if len(clean_text) > 100 else ''}"*
+
+**Analysis Details:**
+- **Negative:** {probabilities[0][0].item():.1%}
+- **Neutral:** {probabilities[0][1].item():.1%}  
+- **Positive:** {probabilities[0][2].item():.1%}
+
+**Model Status:** ✅ Prediction completed successfully
+        """
+        
+        status_message = f"✅ Analysis complete - {predicted_sentiment} sentiment detected with {confidence:.1%} confidence"
+        
+        return result_message, confidence_data, predicted_sentiment, status_message
+        
+    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)}"
+
+def create_gradio_interface():
+    """Create enhanced Gradio interface with model status"""
+    
+    # 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;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="BERT Sentiment Analyzer", 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 using fine-tuned BERT</p>
+            <p><strong>🌍 Permanently hosted on Hugging Face Spaces</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:")
+                examples = gr.Examples(
+                    examples=[
+                        ["This product exceeded all my expectations! Outstanding quality and excellent customer service."],
+                        ["I'm completely disappointed with this purchase. Poor quality and terrible customer support."],
+                        ["The product is decent. It works as described but nothing extraordinary."],
+                        ["Best purchase I've made this year! Highly recommend to everyone."],
+                        ["Absolutely horrible experience. Would never buy from this company again."],
+                        ["It's okay, good value for the price but could be improved."],
+                        ["The delivery was fast and the packaging was perfect!"],
+                        ["Customer service was unhelpful and rude."],
+                        ["The product I received was damaged. Unacceptable."]
+                    ],
+                    inputs=text_input,
+                    label=None
+                )
+            
+            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 & Technical Details", open=False):
+            gr.Markdown(f"""
+            ### 🧠 Model Architecture
+            - **Base Model:** BERT (bert-base-uncased)
+            - **Task:** Multi-class sentiment classification
+            - **Classes:** Negative 😞, Neutral 😐, Positive 😊
+            - **Max Sequence Length:** 128 tokens
+            - **Device:** {model_device}
+            
+            ### 📊 Training Configuration
+            - **Optimizer:** AdamW (Learning Rate: 2e-5)
+            - **Epochs:** 3
+            - **Batch Size:** 16
+            - **Training Data:** Customer feedback dataset
+            
+            ### ⚙️ How It Works
+            1. **Text Processing:** Input text is tokenized using BERT tokenizer
+            2. **Encoding:** BERT encoder processes the tokens with self-attention
+            3. **Classification:** A classification head outputs probability scores
+            4. **Prediction:** The class with highest probability is selected
+            
+            ### 🚀 Usage Instructions
+            1. **Enter text** in the input box above
+            2. **Click 'Analyze Sentiment'** to get predictions
+            3. **View results** including confidence scores and detailed breakdown
+            4. **Try the examples** to see how the model performs on different texts
+            """)
+        
+        # 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 and loaded_tokenizer is not None:
+                return """<div class="model-status status-success">✅ Model Loaded Successfully - Ready for Analysis!</div>"""
+            else:
+                return """<div class="model-status status-error">❌ Model Not Loaded - Using base BERT model</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
+        )
+    
+    return demo
+
+# Load model and launch interface
+if __name__ == "__main__":
+    print("🚀 Starting BERT Sentiment Analyzer...")
+    print("=" * 60)
+    
+    # Load the model
+    model_loaded = load_trained_model()
+    
+    if model_loaded:
+        print("\n🎉 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("=" * 60)
+        
+        # Launch the interface
+        demo.launch(
+            share=True,
+            show_error=True,
+            inbrowser=True
+        )
+    else:
+        print("\n❌ Model loading failed, but launching interface anyway...")
+        print("💡 The app will use base BERT model (not fine-tuned)")
+        demo = create_gradio_interface()
+        demo.launch(share=True)