Update app.py

app.py

@@ -13,357 +13,671 @@ from nltk.corpus import stopwords
 from tensorflow.keras.layers import Layer
 from tensorflow.keras import backend as K
 import time
+import matplotlib.pyplot as plt
+import seaborn as sns
 
-# Download NLTK resources
+# Configure environment
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'  # Suppress TensorFlow logs
 nltk.download('punkt', quiet=True)
 nltk.download('stopwords', quiet=True)
 
-# --- Custom Attention Layer ---
-@tf.keras.utils.register_keras_serializable(package="CustomLayers")
-class SimpleAttention(Layer):
-    def __init__(self, **kwargs):
-        super(SimpleAttention, self).__init__(**kwargs)
+# --- Professional Custom Attention Layer ---
+@tf.keras.utils.register_keras_serializable(package="SentimentAnalysis")
+class EnhancedAttention(Layer):
+    """Advanced attention mechanism with context preservation"""
+    def __init__(self, return_attention=False, **kwargs):
+        self.return_attention = return_attention
+        super(EnhancedAttention, self).__init__(**kwargs)
 
     def build(self, input_shape):
         self.W = self.add_weight(
             name="attention_weight",
-            shape=(input_shape[-1], 1),
+            shape=(input_shape[-1], input_shape[-1]),
             initializer="glorot_uniform",
             trainable=True
         )
-        super(SimpleAttention, self).build(input_shape)
+        self.b = self.add_weight(
+            name="attention_bias",
+            shape=(input_shape[-1],),
+            initializer="zeros",
+            trainable=True
+        )
+        self.u = self.add_weight(
+            name="context_vector",
+            shape=(input_shape[-1],),
+            initializer="glorot_uniform",
+            trainable=True
+        )
+        super(EnhancedAttention, self).build(input_shape)
 
     def call(self, inputs):
-        e = K.tanh(K.dot(inputs, self.W))
-        e = K.squeeze(e, axis=-1)
-        alpha = K.softmax(e, axis=1)
-        alpha = K.expand_dims(alpha, axis=-1)
-        context = inputs * alpha
-        return K.sum(context, axis=1)
+        # Attention mechanism with learned context
+        v = K.tanh(K.dot(inputs, self.W) + self.b
+        vu = K.dot(v, K.expand_dims(self.u))
+        alphas = K.softmax(vu, axis=1)
+        output = K.sum(inputs * alphas, axis=1)
+        
+        if self.return_attention:
+            return [output, alphas]
+        return output
 
     def compute_output_shape(self, input_shape):
+        if self.return_attention:
+            return [(input_shape[0], input_shape[2]), (input_shape[0], input_shape[1])]
         return (input_shape[0], input_shape[2])
 
-# --- Enhanced Text Preprocessing ---
-def preprocess_for_lstm(text, remove_stopwords=False):
-    if not isinstance(text, str) or not text.strip():
-        return ""
-
-    try:
-        # Handle neutral/negation phrases
-        text = re.sub(r'\b(not bad|not great|okay|so-so|meh)\b', ' neutral_term ', text, flags=re.IGNORECASE)
-        
-        # Improved negation handling
-        negation_patterns = [
-            r'\b(not|no|never|without)\b [\w]+',
-            r'\b(less than|barely|hardly|scarcely)\b [\w]+',
-            r'\b(avoid|skip|doubt|problem|issue)\b'
-        ]
-        for pattern in negation_patterns:
-            text = re.sub(pattern, ' negation_term ', text, flags=re.IGNORECASE)
+# --- Professional Text Preprocessing ---
+class TextPreprocessor:
+    """Advanced linguistic processor with domain-specific rules"""
+    def __init__(self):
+        self.negation_phrases = {
+            'not', 'no', 'never', 'without', "don't", "isn't", "wasn't", "shouldn't", 
+            "couldn't", "wouldn't", "aren't", "weren't", "doesn't", "didn't", "won't",
+            "can't", "cannot", "nobody", "none", "nothing", "nowhere", "neither", "nor"
+        }
+        self.intensifiers = {
+            'very', 'extremely', 'absolutely', 'completely', 'totally', 'utterly', 
+            'highly', 'exceptionally', 'remarkably', 'incredibly', 'amazingly'
+        }
+        self.diminishers = {
+            'slightly', 'somewhat', 'barely', 'hardly', 'scarcely', 'marginally',
+            'partially', 'moderately', 'faintly', 'minimally', 'negligibly'
+        }
+        self.positive_indicators = {
+            'love', 'excellent', 'awesome', 'fantastic', 'great', 'wonderful', 
+            'superb', 'outstanding', 'brilliant', 'perfect', 'favorite', 'best'
+        }
+        self.negative_indicators = {
+            'hate', 'terrible', 'awful', 'horrible', 'worst', 'bad', 'poor', 
+            'disappointing', 'avoid', 'problem', 'issue', 'failure', 'disaster'
+        }
+        self.neutral_indicators = {
+            'okay', 'average', 'adequate', 'sufficient', 'acceptable', 'moderate',
+            'tolerable', 'passable', 'satisfactory', 'standard', 'neutral'
+        }
         
-        # Emoji handling
+    def preprocess(self, text):
+        """Full linguistic processing pipeline"""
+        if not isinstance(text, str) or not text.strip():
+            return ""
+            
+        try:
+            # Phase 1: Structural normalization
+            text = self._normalize_structure(text)
+            
+            # Phase 2: Semantic enrichment
+            text = self._enhance_semantics(text)
+            
+            # Phase 3: Token-level processing
+            tokens = self._process_tokens(text)
+            
+            return ' '.join(tokens)
+            
+        except Exception as e:
+            return text.lower()
+
+    def _normalize_structure(self, text):
+        """Text structure normalization"""
+        # Emoji handling with sentiment preservation
         text = emoji.demojize(text, delimiters=("", ""))
         
-        # Contractions
+        # Advanced contraction handling
         text = contractions.fix(text)
         
-        # URL/mention replacement
+        # URL/mention standardization
         text = re.sub(r'https?://\S+|www\.\S+', ' URL ', text)
         text = re.sub(r'@\S+', ' USER ', text)
-        text = re.sub(r'\s+', ' ', text).strip().lower()
         
+        # Whitespace normalization
+        text = re.sub(r'\s+', ' ', text).strip()
+        
+        # Case normalization
+        return text.lower()
+
+    def _enhance_semantics(self, text):
+        """Semantic enhancement for sentiment analysis"""
+        # Handle negations with context preservation
+        for phrase in self.negation_phrases:
+            text = re.sub(rf'\b{phrase}\b [\w]+', f' NEGATION_{phrase} ', text)
+        
+        # Boost contrastive conjunctions
+        text = re.sub(r'\b(but|however|although|yet)\b', ' CONTRAST_TERM ', text)
+        
+        # Enhance intensifiers/diminishers
+        for word in self.intensifiers:
+            text = re.sub(rf'\b{word}\b', f' INTENSIFIER_{word} ', text)
+        for word in self.diminishers:
+            text = re.sub(rf'\b{word}\b', f' DIMINISHER_{word} ', text)
+            
+        # Sentiment indicator boosting
+        for word in self.positive_indicators:
+            text = re.sub(rf'\b{word}\b', f' POSITIVE_{word} ', text)
+        for word in self.negative_indicators:
+            text = re.sub(rf'\b{word}\b', f' NEGATIVE_{word} ', text)
+        for word in self.neutral_indicators:
+            text = re.sub(rf'\b{word}\b', f' NEUTRAL_{word} ', text)
+            
+        # Handle numerical sentiment (ratings 1-5, 1-10)
+        text = re.sub(r'\b([1-9]|10)/10\b', lambda m: f' RATING_{m.group(1)}_10 ', text)
+        text = re.sub(r'\b([1-5])/5\b', lambda m: f' RATING_{m.group(1)}_5 ', text)
+        
+        return text
+
+    def _process_tokens(self, text):
+        """Token-level processing pipeline"""
         # Emoticon preservation
         emoticons = re.findall(r'(?::|;|=)(?:-)?(?:\)|\(|D|P)', text)
         text = re.sub(r'[^\w\s!?.,]', ' ', text)
         
-        # Tokenization with special handling
+        # Tokenization
         tokens = word_tokenize(text)
-        processed_tokens = []
+        processed = []
+        
         for token in tokens:
             if not token.strip():
                 continue
                 
-            # Boost neutral signal
-            if token in {'neutral_term', 'negation_term'}:
-                processed_tokens.append(token)
+            # Preserve enriched tokens
+            if token.startswith(('NEGATION_', 'CONTRAST_', 'INTENSIFIER_', 
+                               'DIMINISHER_', 'POSITIVE_', 'NEGATIVE_', 'NEUTRAL_',
+                               'RATING_')):
+                processed.append(token)
                 continue
                 
-            # Handle intensifiers/diminishers
-            if token in {'very', 'extremely', 'absolutely'}:
-                processed_tokens.append('intensifier')
-            elif token in {'slightly', 'somewhat', 'barely'}:
-                processed_tokens.append('diminisher')
-            else:
-                processed_tokens.append(token)
-                
-        processed_tokens.extend(emoticons)
-        return ' '.join(processed_tokens)
-
-    except Exception:
-        return text.lower()
-
-# --- Load model resources ---
-@st.cache_resource
-def load_model():
-    MODEL_DIR = "model_files/models"
-    model_path = f"{MODEL_DIR}/simplified_lstm_20250622-195716_best.keras"
-    tokenizer_path = f"{MODEL_DIR}/simplified_lstm_20250622-195716_tokenizer.pickle"
-    label_mapping_path = f"{MODEL_DIR}/simplified_lstm_20250622-195716_label_mapping.pickle"
-
-    # Verify files exist
-    for path in [model_path, tokenizer_path, label_mapping_path]:
-        if not os.path.exists(path):
-            st.error(f"Critical error: File not found - {path}")
-            st.stop()
+            processed.append(token)
+            
+        return processed + emoticons
 
-    # Load model with custom layers
-    try:
-        model = tf.keras.models.load_model(
+# --- Model Management System ---
+class SentimentAnalyzer:
+    """Professional sentiment analysis system"""
+    def __init__(self, model_dir="model_files/models"):
+        self.model_dir = model_dir
+        self.model = None
+        self.tokenizer = None
+        self.label_mapping = None
+        self.preprocessor = TextPreprocessor()
+        self.max_len = 50
+        self.confidence_threshold = 0.6
+        self.load_resources()
+        
+    def load_resources(self):
+        """Load model artifacts with enhanced validation"""
+        model_path = f"{self.model_dir}/simplified_lstm_20250622-195716_best.keras"
+        tokenizer_path = f"{self.model_dir}/simplified_lstm_20250622-195716_tokenizer.pickle"
+        label_path = f"{self.model_dir}/simplified_lstm_20250622-195716_label_mapping.pickle"
+        
+        # Validate resources
+        missing = [p for p in [model_path, tokenizer_path, label_path] if not os.path.exists(p)]
+        if missing:
+            raise FileNotFoundError(f"Missing model resources: {', '.join(missing)}")
+            
+        # Load model with custom components
+        self.model = tf.keras.models.load_model(
             model_path,
             custom_objects={
-                'SimpleAttention': SimpleAttention,
+                'EnhancedAttention': EnhancedAttention,
                 'SpatialDropout1D': tf.keras.layers.SpatialDropout1D
             },
             compile=False
         )
-    except Exception as e:
-        st.error(f"Model loading failed: {str(e)}")
-        st.stop()
-
-    # Load tokenizer and label mapping
-    with open(tokenizer_path, "rb") as handle:
-        tokenizer = pickle.load(handle)
-    
-    with open(label_mapping_path, "rb") as handle:
-        label_mapping = pickle.load(handle)
-        
-    return model, tokenizer, label_mapping
-
-# --- Initialize resources ---
-try:
-    MAX_LEN = 50
-    model, tokenizer, label_mapping = load_model()
-    index_to_label = {v: k for k, v in label_mapping.items()}
-except Exception as e:
-    st.error(f"Initialization failed: {str(e)}")
-    st.stop()
-
-# --- Enhanced Prediction Pipeline ---
-def predict_sentiment(text):
-    start_time = time.time()
-    processed_text = preprocess_for_lstm(text)
-    
-    # Handle empty sequences
-    if not processed_text.strip():
-        return "0.0", 0.0  # Default to neutral
-    
-    # Tokenize with fallback
-    seq = tokenizer.texts_to_sequences([processed_text])
-    if not seq or not any(seq[0]):
-        seq = [[tokenizer.word_index.get('neutral_term', 1)]]
-    
-    padded = tf.keras.preprocessing.sequence.pad_sequences(
-        seq, 
-        maxlen=MAX_LEN,
-        padding='post',
-        truncating='post',
-        value=0
-    )
-    
-    # Predict with confidence threshold
-    try:
-        prediction = model.predict(padded, verbose=0)[0]
-        label_idx = np.argmax(prediction)
-        confidence = prediction[label_idx]
-        
-        # Apply confidence-based adjustment
-        if confidence < 0.65:  # Uncertain predictions
-            # Check for neutral indicators
-            if 'neutral_term' in processed_text or 'diminisher' in processed_text:
-                label_idx = list(label_mapping.values()).index(1)  # Force neutral
         
-        proc_time = time.time() - start_time
+        # Load supporting artifacts
+        with open(tokenizer_path, "rb") as f:
+            self.tokenizer = pickle.load(f)
+        with open(label_path, "rb") as f:
+            self.label_mapping = pickle.load(f)
+            
+        # Create reverse mapping
+        self.index_to_label = {v: k for k, v in self.label_mapping.items()}
         
-        # Store debug info
-        st.session_state.last_prediction = {
-            "raw_text": text,
-            "processed_text": processed_text,
-            "probabilities": prediction.round(4).tolist(),
-            "predicted_label": index_to_label[label_idx],
-            "confidence": float(confidence),
-            "processing_time": proc_time
-        }
+    def predict(self, text):
+        """Professional prediction pipeline with linguistic analysis"""
+        start_time = time.time()
         
-        return index_to_label[label_idx], confidence
+        # Preprocess with advanced linguistic rules
+        processed = self.preprocessor.preprocess(text)
         
-    except Exception as e:
-        return "0.0", 0.0
-
-# --- Streamlit App UI ---
-st.set_page_config(page_title="High-Accuracy Sentiment Analysis", layout="wide")
-st.title("💬 Advanced Sentiment Analysis")
-
-# Initialize session state
-if 'last_prediction' not in st.session_state:
-    st.session_state.last_prediction = None
-
-# Debug info
-with st.expander("🔧 Debug Information", expanded=False):
-    st.write(f"**Input Shape:** {model.input_shape}")
-    st.write(f"**Classes:** {label_mapping}")
-    
-    if st.session_state.last_prediction:
-        st.json(st.session_state.last_prediction)
-
-# Validation tests with explanations
-test_cases = [
-    ("I love this product! It's absolutely amazing 😍", "1.0", "Clear positive"),
-    ("Terrible experience, worst purchase ever", "-1.0", "Clear negative"),
-    ("The item is okay, nothing special", "0.0", "Neutral - baseline"),
-    ("Not bad but could be better", "0.0", "Neutral - nuanced"),
-    ("Avoid this company at all costs", "-1.0", "Negative - strong intent"),
-    ("It's barely acceptable", "0.0", "Neutral - diminisher"),
-    ("Service was not great", "0.0", "Neutral - negation"),
-    ("Best decision I've ever made!", "1.0", "Positive - intensifier")
-]
-
-with st.expander("🧪 Validation Tests", expanded=True):
-    if st.button("Run Validation Suite", type="primary"):
-        results = []
-        for text, expected, desc in test_cases:
-            label, conf = predict_sentiment(text)
-            match = "✓" if label == expected else "✗"
-            results.append({
-                "Text": text,
-                "Description": desc,
-                "Expected": expected,
-                "Predicted": label,
-                "Confidence": f"{conf:.1%}",
-                "Match": match
-            })
+        # Fallback for empty content
+        if not processed.strip():
+            return "0.0", 0.0, processed, {}
+            
+        # Tokenization with advanced fallback
+        seq = self.tokenizer.texts_to_sequences([processed])
+        if not seq or not any(seq[0]):
+            seq = [[self.tokenizer.word_index.get('neutral_term', 1)]]
+            
+        # Padding to match training specs
+        padded = tf.keras.preprocessing.sequence.pad_sequences(
+            seq, 
+            maxlen=self.max_len,
+            padding='post',
+            truncating='post',
+            value=0
+        )
         
-        df_results = pd.DataFrame(results)
-        st.dataframe(df_results.style.apply(
-            lambda row: ['background-color: #ffcccc' if row.Match == "✗" else '' for _ in row],
-            axis=1
-        ))
-
-# Single text analysis
-with st.form("analysis_form"):
-    st.subheader("🔍 Analyze Text")
-    user_input = st.text_area("Enter text:", height=150, 
-                            value="The service was acceptable but not outstanding")
-    submitted = st.form_submit_button("Analyze Sentiment", type="primary")
-    
-    if submitted and user_input.strip():
-        with st.spinner("Analyzing..."):
-            label, confidence = predict_sentiment(user_input)
+        # Prediction execution
+        try:
+            prediction = self.model.predict(padded, verbose=0)[0]
+            label_idx = np.argmax(prediction)
+            confidence = prediction[label_idx]
+            raw_label = self.index_to_label[label_idx]
+            
+            # Advanced confidence adjustment
+            adjusted_label, confidence = self._apply_business_rules(
+                processed, raw_label, confidence, prediction
+            )
             
-            # Display results with explanation
-            sentiment_map = {
-                "1.0": ("Positive 😊", "green"),
-                "0.0": ("Neutral 😐", "blue"),
-                "-1.0": ("Negative 😠", "red")
-            }
+            # Generate linguistic insights
+            insights = self._generate_insights(processed, prediction)
             
-            display_text, color = sentiment_map.get(label, ("Unknown", "gray"))
+            return adjusted_label, confidence, processed, insights
             
-            st.markdown(f"""
-            <div style="border-left: 5px solid {color}; padding: 10px; background-color: #f8f9fa; border-radius: 5px;">
-                <h3 style="color: {color};">{display_text}</h3>
-                <p>Confidence: <b>{confidence:.1%}</b></p>
-            </div>
-            """, unsafe_allow_html=True)
+        except Exception as e:
+            return "0.0", 0.0, processed, {"error": str(e)}
             
-            # Show processing insights
-            if st.session_state.last_prediction:
-                with st.expander("Analysis Details"):
-                    st.write(f"**Processed Text:** `{st.session_state.last_prediction['processed_text']}`")
+    def _apply_business_rules(self, processed_text, raw_label, confidence, prediction):
+        """Apply domain-specific business rules to predictions"""
+        # Rule 1: Low confidence override
+        if confidence < self.confidence_threshold:
+            # Neutral content indicators
+            neutral_terms = {'neutral_term', 'contrast_term', 'diminisher'}
+            if any(term in processed_text for term in neutral_terms):
+                return "0.0", min(confidence + 0.15, 0.95)  # Boost towards neutral
+                
+            # Negation context handling
+            if 'negation_' in processed_text:
+                # Switch polarity for negated positives
+                if raw_label == "1.0":
+                    return "-1.0", prediction[0]  # Flip to negative
+                # Handle negated negatives
+                elif raw_label == "-1.0":
+                    return "0.0", prediction[1]  # Downgrade to neutral
                     
-                    # Sentiment probability visualization
-                    prob_data = {
-                        "Negative": st.session_state.last_prediction['probabilities'][0],
-                        "Neutral": st.session_state.last_prediction['probabilities'][1],
-                        "Positive": st.session_state.last_prediction['probabilities'][2]
-                    }
-                    st.bar_chart(prob_data)
-
-# --- CSV Batch Processing Section ---
-st.subheader("📊 Batch Analysis from CSV")
-st.write("Upload a CSV file containing text data to analyze multiple entries at once")
-
-uploaded_file = st.file_uploader("Choose a CSV file", type=["csv"], 
-                                 help="File must contain a 'text' column with content to analyze")
+        # Rule 2: Contrast term handling
+        if 'contrast_term' in processed_text:
+            # Split text by contrast terms
+            parts = re.split(r'\bcontrast_term\b', processed_text)
+            if len(parts) > 1:
+                # Analyze sentiment of each part
+                sentiments = []
+                for part in parts:
+                    if part.strip():
+                        _, _, _, part_insights = self.predict(part)
+                        sentiments.append(part_insights.get('dominant_sentiment', 'neutral'))
+                
+                # Apply contrast rules
+                if sentiments:
+                    if sentiments[0] == "positive" and sentiments[-1] == "negative":
+                        return "-1.0", max(prediction[0], confidence)
+                    elif sentiments[0] == "negative" and sentiments[-1] == "positive":
+                        return "1.0", max(prediction[2], confidence)
+        
+        # Rule 3: Rating-based override
+        rating_match = re.search(r'rating_(\d+)_(5|10)', processed_text)
+        if rating_match:
+            rating = int(rating_match.group(1))
+            scale = int(rating_match.group(2))
+            normalized = rating / scale
+            
+            if normalized < 0.4:
+                return "-1.0", 0.95
+            elif normalized < 0.7:
+                return "0.0", 0.95
+            else:
+                return "1.0", 0.95
+        
+        return raw_label, confidence
+        
+    def _generate_insights(self, processed_text, prediction):
+        """Generate linguistic insights from text"""
+        insights = {
+            "dominant_sentiment": "",
+            "key_phrases": [],
+            "sentiment_score": float(prediction[2] - prediction[0]),  # Positive - Negative
+            "confidence_level": ""
+        }
+        
+        # Determine dominant sentiment
+        if prediction[2] > 0.7:  # Positive
+            insights["dominant_sentiment"] = "positive"
+        elif prediction[0] > 0.7:  # Negative
+            insights["dominant_sentiment"] = "negative"
+        else:  # Neutral
+            insights["dominant_sentiment"] = "neutral"
+            
+        # Confidence categorization
+        max_conf = max(prediction)
+        if max_conf > 0.9:
+            insights["confidence_level"] = "high"
+        elif max_conf > 0.7:
+            insights["confidence_level"] = "medium"
+        else:
+            insights["confidence_level"] = "low"
+            
+        # Extract key phrases
+        key_terms = re.findall(
+            r'(POSITIVE_\w+|NEGATIVE_\w+|NEUTRAL_\w+|INTENSIFIER_\w+|DIMINISHER_\w+|NEGATION_\w+)', 
+            processed_text
+        )
+        insights["key_phrases"] = list(set(key_terms))[:5]  # Top 5 unique
+        
+        return insights
 
-if uploaded_file is not None:
-    try:
-        # Read CSV file
-        df = pd.read_csv(uploaded_file)
+# --- Streamlit Application ---
+class SentimentAnalysisApp:
+    """Professional sentiment analysis application"""
+    def __init__(self):
+        self.analyzer = None
+        self.initialize()
+        
+    def initialize(self):
+        """Initialize application resources"""
+        st.set_page_config(
+            page_title="Enterprise Sentiment Analyzer", 
+            layout="wide",
+            page_icon="📊"
+        )
         
-        # Verify required column exists
-        if 'text' not in df.columns:
-            st.error("❌ CSV file must contain a column named 'text'")
+        try:
+            self.analyzer = SentimentAnalyzer()
+            st.session_state.analyzer = self.analyzer
+        except Exception as e:
+            st.error(f"System Initialization Failed: {str(e)}")
             st.stop()
             
-        st.success(f"✅ Successfully loaded {len(df)} records")
-        st.dataframe(df.head(3))
+    def run(self):
+        """Run main application"""
+        st.title("📈 Enterprise Sentiment Analysis System")
+        st.markdown("""
+            <style>
+            .positive { color: #4CAF50; font-weight: bold; }
+            .negative { color: #F44336; font-weight: bold; }
+            .neutral { color: #2196F3; font-weight: bold; }
+            .header { border-bottom: 2px solid #eee; padding-bottom: 10px; }
+            .highlight { background-color: #f0f9ff; border-radius: 5px; padding: 15px; }
+            </style>
+        """, unsafe_allow_html=True)
         
-        # Process in batches
-        if st.button("Analyze All Texts", type="primary", key="batch_analyze"):
-            results = []
-            progress_bar = st.progress(0)
-            status_text = st.empty()
+        # Application sections
+        self.render_test_suite()
+        self.render_single_analysis()
+        self.render_batch_analysis()
+        self.render_footer()
+        
+    def render_test_suite(self):
+        """Validation test suite with professional layout"""
+        with st.expander("🧪 VALIDATION TEST SUITE", expanded=True):
+            st.markdown("<h3 class='header'>System Performance Validation</h3>", unsafe_allow_html=True)
+            
+            # Professional test cases
+            test_cases = [
+                ("I love this product! It's absolutely amazing 😍", "1.0", "Clear positive sentiment"),
+                ("Terrible experience, worst purchase ever", "-1.0", "Clear negative sentiment"),
+                ("The item is okay, nothing special", "0.0", "Neutral baseline"),
+                ("Not bad but could be better", "0.0", "Negated negative to neutral"),
+                ("Avoid this company at all costs", "-1.0", "Strong negative intent"),
+                ("It's barely acceptable", "0.0", "Diminisher indicating neutrality"),
+                ("Service was not great", "0.0", "Negated positive to neutral"),
+                ("The product is good but the service is poor", "0.0", "Contrasting sentiments"),
+                ("Best decision I've ever made!", "1.0", "Positive with intensifier"),
+                ("3/5 - Average performance", "0.0", "Numerical rating"),
+                ("Would not recommend to anyone", "-1.0", "Strong negation"),
+                ("Slightly better than expected", "1.0", "Diminisher with positive"),
+                ("Not what I hoped for", "-1.0", "Negative expectation mismatch"),
+                ("Exceptional quality and value", "1.0", "Strong positive indicators"),
+                ("Mediocre at best", "0.0", "Neutral with diminisher")
+            ]
             
-            # Process each row
-            for i, row in enumerate(df.itertuples()):
-                text = str(row.text)
-                label, confidence = predict_sentiment(text)
+            if st.button("🚀 Execute Full Test Suite", type="primary", use_container_width=True):
+                results = []
+                progress_bar = st.progress(0)
+                status_text = st.empty()
                 
-                # Map to human-readable label
-                sentiment_label = {
-                    "1.0": "Positive",
-                    "0.0": "Neutral",
-                    "-1.0": "Negative"
-                }.get(label, "Unknown")
+                for i, (text, expected, desc) in enumerate(test_cases):
+                    label, conf, processed, insights = self.analyzer.predict(text)
+                    match = "✓" if label == expected else "✗"
+                    results.append({
+                        "Text": text,
+                        "Description": desc,
+                        "Expected": expected,
+                        "Predicted": label,
+                        "Confidence": f"{conf:.1%}",
+                        "Match": match
+                    })
+                    
+                    # Update progress
+                    progress = (i + 1) / len(test_cases)
+                    progress_bar.progress(progress)
+                    status_text.text(f"Testing case {i+1}/{len(test_cases)}: {text[:30]}...")
                 
-                results.append({
-                    "Original Text": text,
-                    "Predicted Sentiment": sentiment_label,
-                    "Confidence": f"{confidence:.1%}",
-                    "Raw Label": label
-                })
+                # Display results
+                df_results = pd.DataFrame(results)
                 
-                # Update progress
-                progress = (i + 1) / len(df)
-                progress_bar.progress(progress)
-                status_text.text(f"Processed {i+1}/{len(df)} records ({progress:.0%})")
-            
-            # Create results dataframe
-            results_df = pd.DataFrame(results)
-            
-            # Show results
-            st.subheader("Analysis Results")
-            st.dataframe(results_df)
+                # Highlight mismatches
+                def highlight_mismatch(row):
+                    return ['background-color: #ffdddd' if row.Match == "✗" else '' for _ in row]
+                
+                st.dataframe(
+                    df_results.style.apply(highlight_mismatch, axis=1),
+                    height=600
+                )
+                
+                # Calculate accuracy
+                accuracy = (df_results['Match'] == "✓").mean()
+                st.metric("Test Suite Accuracy", f"{accuracy:.1%}", 
+                         delta_color="normal", 
+                         help="Overall accuracy across test cases")
+                
+                # Display failed cases
+                failed = df_results[df_results['Match'] == "✗"]
+                if not failed.empty:
+                    st.subheader("Improvement Opportunities")
+                    for _, row in failed.iterrows():
+                        st.error(f"**Case:** {row['Description']}")
+                        st.code(f"Text: {row['Text']}\nExpected: {row['Expected']} | Predicted: {row['Predicted']}")
+    
+    def render_single_analysis(self):
+        """Single text analysis with professional presentation"""
+        with st.form("single_analysis_form"):
+            st.markdown("<h3 class='header'>Single Text Analysis</h3>", unsafe_allow_html=True)
             
-            # Download results
-            csv = results_df.to_csv(index=False).encode('utf-8')
-            st.download_button(
-                label="Download Results as CSV",
-                data=csv,
-                file_name="sentiment_analysis_results.csv",
-                mime="text/csv",
-                type="primary"
+            # Text input with examples
+            user_input = st.text_area(
+                "Input Text:", 
+                height=150,
+                placeholder="Enter text to analyze...",
+                value="The product quality was exceptional but delivery was delayed."
             )
             
-            # Sentiment distribution visualization
-            st.subheader("Sentiment Distribution")
-            sentiment_counts = results_df['Predicted Sentiment'].value_counts()
-            st.bar_chart(sentiment_counts)
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                advanced = st.checkbox("Show linguistic insights", value=True)
+            with col2:
+                submitted = st.form_submit_button("🔍 Analyze Sentiment", type="primary", use_container_width=True)
             
-    except Exception as e:
-        st.error(f"Error processing CSV file: {str(e)}")
+            if submitted and user_input.strip():
+                with st.spinner("Performing deep linguistic analysis..."):
+                    # Perform analysis
+                    label, confidence, processed, insights = self.analyzer.predict(user_input)
+                    
+                    # Display main results
+                    sentiment_info = {
+                        "1.0": ("Positive Sentiment", "#4CAF50", "😊"),
+                        "0.0": ("Neutral Sentiment", "#2196F3", "😐"),
+                        "-1.0": ("Negative Sentiment", "#F44336", "😠")
+                    }.get(label, ("Unknown Sentiment", "#9E9E9E", "❓"))
+                    
+                    st.markdown(f"""
+                    <div class='highlight'>
+                        <div style="display: flex; align-items: center; margin-bottom: 15px;">
+                            <h2 style="color: {sentiment_info[1]}; margin: 0;">{sentiment_info[0]} {sentiment_info[2]}</h2>
+                            <div style="margin-left: auto; font-size: 1.2rem;">
+                                Confidence: <b>{confidence:.1%}</b>
+                            </div>
+                        </div>
+                        <div style="font-size: 1.1rem; margin-top: 10px;">
+                            {user_input[:200]}{'...' if len(user_input) > 200 else ''}
+                        </div>
+                    </div>
+                    """, unsafe_allow_html=True)
+                    
+                    # Advanced insights
+                    if advanced:
+                        with st.expander("🧠 Linguistic Analysis Insights", expanded=True):
+                            col1, col2 = st.columns(2)
+                            
+                            with col1:
+                                st.subheader("Text Processing")
+                                st.markdown(f"**Processed Text:**  \n`{processed}`")
+                                
+                                if insights.get("key_phrases"):
+                                    st.subheader("Key Phrases Detected")
+                                    for phrase in insights["key_phrases"]:
+                                        st.markdown(f"- `{phrase}`")
+                            
+                            with col2:
+                                st.subheader("Sentiment Analysis")
+                                # Sentiment distribution
+                                fig, ax = plt.subplots(figsize=(6, 4))
+                                sentiments = ['Negative', 'Neutral', 'Positive']
+                                colors = ['#F44336', '#2196F3', '#4CAF50']
+                                ax.bar(sentiments, insights.get('prediction', [0,0,0]), color=colors)
+                                ax.set_title('Sentiment Probability Distribution')
+                                ax.set_ylim(0, 1)
+                                st.pyplot(fig)
+                                
+                                # Confidence indicator
+                                st.metric("Confidence Level", insights.get("confidence_level", "").title())
+                                
+                                # Sentiment score
+                                score = insights.get("sentiment_score", 0)
+                                sentiment_val = "Positive" if score > 0 else "Negative" if score < 0 else "Neutral"
+                                st.metric("Sentiment Score", f"{score:.2f} ({sentiment_val})")
+    
+    def render_batch_analysis(self):
+        """Professional batch analysis section"""
+        st.markdown("<h3 class='header'>Batch Analysis</h3>", unsafe_allow_html=True)
+        st.markdown("Upload a CSV file for high-volume sentiment processing")
+        
+        uploaded_file = st.file_uploader(
+            "Upload CSV File", 
+            type=["csv"],
+            accept_multiple_files=False,
+            help="File must contain a column named 'text' with content to analyze"
+        )
+        
+        if uploaded_file is not None:
+            try:
+                # Read and validate CSV
+                df = pd.read_csv(uploaded_file)
+                
+                if 'text' not in df.columns:
+                    st.error("Invalid file format: Missing 'text' column")
+                    return
+                    
+                st.success(f"File loaded successfully: {len(df)} records detected")
+                
+                if st.button("🚀 Process Entire Dataset", type="primary", use_container_width=True):
+                    # Create containers for UI
+                    progress_bar = st.progress(0)
+                    status_text = st.empty()
+                    results_container = st.empty()
+                    
+                    # Process dataset
+                    results = []
+                    start_time = time.time()
+                    
+                    for i, row in enumerate(df.itertuples()):
+                        text = str(row.text)
+                        label, confidence, processed, insights = self.analyzer.predict(text)
+                        
+                        # Map to human-readable
+                        sentiment_label = {
+                            "1.0": "Positive",
+                            "0.0": "Neutral",
+                            "-1.0": "Negative"
+                        }.get(label, "Unknown")
+                        
+                        results.append({
+                            "Original Text": text,
+                            "Processed Text": processed,
+                            "Sentiment": sentiment_label,
+                            "Confidence": confidence,
+                            "Raw Label": label
+                        })
+                        
+                        # Update UI every 10 items or last
+                        if i % 10 == 0 or i == len(df)-1:
+                            progress = (i + 1) / len(df)
+                            progress_bar.progress(progress)
+                            
+                            # Update status with performance metrics
+                            elapsed = time.time() - start_time
+                            speed = (i+1) / max(elapsed, 1)  # Items per second
+                            status_text.text(
+                                f"Processed {i+1}/{len(df)} records | "
+                                f"Speed: {speed:.1f} records/sec | "
+                                f"Estimated: {((len(df)-i-1)/max(speed,1)):.0f}s remaining"
+                            )
+                            
+                            # Show preview
+                            preview_df = pd.DataFrame(results[-10:])
+                            results_container.dataframe(preview_df)
+                    
+                    # Create final results
+                    results_df = pd.DataFrame(results)
+                    
+                    # Display analysis summary
+                    st.success("Processing complete! Analysis summary:")
+                    
+                    # Sentiment distribution
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.subheader("Sentiment Distribution")
+                        fig, ax = plt.subplots(figsize=(8, 5))
+                        sentiment_counts = results_df['Sentiment'].value_counts()
+                        colors = ['#F44336' if s == 'Negative' else '#2196F3' if s == 'Neutral' else '#4CAF50' 
+                                 for s in sentiment_counts.index]
+                        ax.pie(sentiment_counts, labels=sentiment_counts.index, autopct='%1.1f%%', 
+                              colors=colors, startangle=90)
+                        ax.axis('equal')
+                        st.pyplot(fig)
+                        
+                    with col2:
+                        st.subheader("Confidence Distribution")
+                        fig, ax = plt.subplots(figsize=(8, 5))
+                        sns.histplot(results_df['Confidence'], bins=20, kde=True, ax=ax)
+                        ax.set_xlabel("Confidence Score")
+                        ax.set_ylabel("Count")
+                        ax.set_title("Prediction Confidence Distribution")
+                        st.pyplot(fig)
+                    
+                    # Download functionality
+                    csv = results_df.to_csv(index=False).encode('utf-8')
+                    st.download_button(
+                        "💾 Download Full Analysis",
+                        csv,
+                        "sentiment_analysis_results.csv",
+                        mime="text/csv",
+                        type="primary",
+                        use_container_width=True
+                    )
+                    
+            except Exception as e:
+                st.error(f"Batch processing failed: {str(e)}")
+    
+    def render_footer(self):
+        """Professional application footer"""
+        st.markdown("---")
+        st.markdown("""
+            <div style="text-align: center; color: #777; padding: 20px;">
+                <p>Enterprise Sentiment Analysis System v3.1 • Powered by Deep Learning</p>
+                <p>© 2025 Sentiment Analytics Inc. • All rights reserved</p>
+            </div>
+        """, unsafe_allow_html=True)
 
-# Footer
-st.markdown("---")
-st.caption("Enhanced Sentiment Analysis | Neural Engine v2.1 | Confidence Threshold: 65%")
+# --- Application Execution ---
+if __name__ == "__main__":
+    app = SentimentAnalysisApp()
+    app.run()