Update app.py

app.py

@@ -26,40 +26,40 @@ class FeatureExtractor(tf.keras.layers.Layer):
         super(FeatureExtractor, self).__init__(**kwargs)
         
     def build(self, input_shape):
-        self.contrast_kernel = self.add_weight(
-            name='contrast_kernel', 
-            shape=(input_shape[-1], 1),
-            initializer='glorot_uniform'
-        )
-        self.negation_kernel = self.add_weight(
-            name='negation_kernel',
-            shape=(input_shape[-1], 1),
-            initializer='glorot_uniform'
-        )
-        self.intensifier_kernel = self.add_weight(
-            name='intensifier_kernel',
-            shape=(input_shape[-1], 1),
-            initializer='glorot_uniform'
-        )
+        # We'll create trainable weights for feature detection
+        self.contrast_kernel = self.add_weight(name='contrast_kernel', 
+                                              shape=(input_shape[-1], 1),
+                                              initializer='glorot_uniform')
+        self.negation_kernel = self.add_weight(name='negation_kernel',
+                                              shape=(input_shape[-1], 1),
+                                              initializer='glorot_uniform')
+        self.intensifier_kernel = self.add_weight(name='intensifier_kernel',
+                                                 shape=(input_shape[-1], 1),
+                                                 initializer='glorot_uniform')
         super(FeatureExtractor, self).build(input_shape)
         
     def call(self, inputs):
-        # Detect features
+        # Detect contrast indicators
         contrast = tf.tensordot(inputs, self.contrast_kernel, axes=1)
         contrast = tf.squeeze(contrast, axis=-1)
+        contrast = tf.sigmoid(contrast)
         
+        # Detect negation patterns
         negation = tf.tensordot(inputs, self.negation_kernel, axes=1)
         negation = tf.squeeze(negation, axis=-1)
+        negation = tf.sigmoid(negation)
         
+        # Detect intensifiers/diminishers
         intensifier = tf.tensordot(inputs, self.intensifier_kernel, axes=1)
         intensifier = tf.squeeze(intensifier, axis=-1)
+        intensifier = tf.sigmoid(intensifier)
         
         # Combine features
         features = tf.stack([contrast, negation, intensifier], axis=-1)
         return features
 
     def compute_output_shape(self, input_shape):
-        return (input_shape[0], input_shape[1], 3)
+        return (input_shape[0], input_shape[1], 3)  # (batch_size, seq_length, 3 features)
 
 @tf.keras.utils.register_keras_serializable(package="CustomLayers")
 class SentimentAdjuster(tf.keras.layers.Layer):
@@ -119,11 +119,12 @@ class SentimentAdjuster(tf.keras.layers.Layer):
         return adjusted
 
     def compute_output_shape(self, input_shape):
+        # Same as predictions shape
         return input_shape[0]
 
 @tf.keras.utils.register_keras_serializable(package="CustomLayers")
 class SimpleAttention(tf.keras.layers.Layer):
-    def __init__(self, **kwargs):
+        def __init__(self, **kwargs):
         super(SimpleAttention, self).__init__(**kwargs)
 
     def build(self, input_shape):
@@ -136,16 +137,17 @@ class SimpleAttention(tf.keras.layers.Layer):
         super(SimpleAttention, self).build(input_shape)
 
     def call(self, inputs):
-        e = tf.keras.backend.tanh(tf.keras.backend.dot(inputs, self.W))
-        e = tf.keras.backend.squeeze(e, axis=-1)
-        alpha = tf.keras.backend.softmax(e, axis=1)
-        alpha = tf.keras.backend.expand_dims(alpha, axis=-1)
+        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 tf.keras.backend.sum(context, axis=1)
+        return K.sum(context, axis=1)
 
     def compute_output_shape(self, input_shape):
         return (input_shape[0], input_shape[2])
 
+
 # --- Text Preprocessing ---
 def preprocess_for_lstm(text, remove_stopwords=False):
     if not isinstance(text, str) or not text.strip():
@@ -233,15 +235,14 @@ def preprocess_for_lstm(text, remove_stopwords=False):
 
     except Exception:
         return text.lower()
-
-
+        
 # --- Load model resources ---
 @st.cache_resource
 def load_model():
     MODEL_DIR = "model_files/models"
-    model_path = f"{MODEL_DIR}/enhanced_lstm_20250624-222759_best.keras"
-    tokenizer_path = f"{MODEL_DIR}/enhanced_lstm_20250624-222759_tokenizer.pickle"
-    label_mapping_path = f"{MODEL_DIR}/enhanced_lstm_20250624-222759_label_mapping.pickle"
+    model_path = f"{MODEL_DIR}/simplified_lstm_{TIMESTAMP}_best.keras"
+    tokenizer_path = f"{MODEL_DIR}/simplified_lstm_{TIMESTAMP}_tokenizer.pickle"
+    label_mapping_path = f"{MODEL_DIR}/simplified_lstm_{TIMESTAMP}_label_mapping.pickle"
 
     # Verify files exist
     for path in [model_path, tokenizer_path, label_mapping_path]:
@@ -342,337 +343,4 @@ def predict_sentiment(text):
     except Exception as e:
         return "0.0", 0.0, "", {"error": str(e)}
 
-# [Keep the rest of your app.py UI code unchanged]
-
-# --- Streamlit App UI ---
-st.set_page_config(
-    page_title="Professional Sentiment Analyzer", 
-    layout="wide",
-    page_icon="📊"
-)
-st.title("📊 Professional Sentiment Analysis")
-st.markdown("""
-    <style>
-    .feature-badge {
-        display: inline-block;
-        padding: 0.25em 0.6em;
-        font-size: 75%;
-        font-weight: 700;
-        line-height: 1;
-        text-align: center;
-        white-space: nowrap;
-        vertical-align: baseline;
-        border-radius: 0.25rem;
-        margin-right: 5px;
-        margin-bottom: 5px;
-    }
-    .positive-badge { background-color: #4CAF50; color: white; }
-    .negative-badge { background-color: #F44336; color: white; }
-    .neutral-badge { background-color: #2196F3; color: white; }
-    .feature-badge-default { background-color: #6c757d; color: white; }
-    .header-box {
-        border-radius: 10px;
-        padding: 20px;
-        margin-bottom: 20px;
-        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
-    }
-    .success-box { background-color: #e8f5e9; border-left: 5px solid #4CAF50; }
-    .info-box { background-color: #e3f2fd; border-left: 5px solid #2196F3; }
-    .warning-box { background-color: #ffecb3; border-left: 5px solid #ffc107; }
-    .danger-box { background-color: #ffebee; border-left: 5px solid #F44336; }
-    </style>
-""", unsafe_allow_html=True)
-
-# Initialize session state
-if 'last_prediction' not in st.session_state:
-    st.session_state.last_prediction = None
-if 'analysis_history' not in st.session_state:
-    st.session_state.analysis_history = []
-
-# Model info sidebar
-with st.sidebar:
-    st.header("Model Information")
-    st.write(f"**Model Name:** Simplified LSTM with Attention")
-    st.write(f"**Input Shape:** {model.input_shape}")
-    st.write(f"**Classes:**")
-    for label, data in SENTIMENT_MAP.items():
-        st.markdown(f"- {data['display']} `{label}`")
-    
-    st.divider()
-    st.header("Configuration")
-    confidence_threshold = st.slider(
-        "Confidence Threshold", 
-        min_value=0.5, max_value=0.9, value=0.65, step=0.05,
-        help="Minimum confidence level for definitive sentiment classification"
-    )
-    
-    st.divider()
-    st.header("Analysis History")
-    if st.session_state.analysis_history:
-        for i, item in enumerate(st.session_state.analysis_history[:5]):
-            st.caption(f"{i+1}. {item['text'][:50]}... → {SENTIMENT_MAP[item['label']]['display']}")
-    else:
-        st.caption("No history yet")
-
-# 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"),
-    ("The product is good but the service is terrible", "0.0", "Mixed sentiment"),
-    ("I'm extremely satisfied with my purchase", "1.0", "Positive with intensifier"),
-    ("Somewhat disappointed with the quality", "0.0", "Neutral with diminisher"),
-    ("Absolutely horrible customer service", "-1.0", "Negative with amplifier"),
-    ("The design is excellent, however the battery life is poor", "0.0", "Contrast indicator"),
-    ("Wow! This exceeded all my expectations", "1.0", "Positive exclamation"),
-    ("Ugh, this is disgusting", "-1.0", "Negative exclamation")
-]
-
-with st.expander("🧪 Validation Test Suite", expanded=True):
-    cols = st.columns([3, 1])
-    with cols[0]:
-        st.subheader("Comprehensive Validation Tests")
-    with cols[1]:
-        if st.button("Run All Tests", type="primary", key="run_tests"):
-            test_results = []
-            
-            with st.spinner("Running validation suite..."):
-                for text, expected, desc in test_cases:
-                    label, confidence, _, debug_info = predict_sentiment(text)
-                    match = label == expected
-                    test_results.append({
-                        "Text": text,
-                        "Description": desc,
-                        "Expected": SENTIMENT_MAP[expected]["display"],
-                        "Predicted": SENTIMENT_MAP[label]["display"],
-                        "Confidence": f"{confidence:.1%}",
-                        "Result": "Pass ✓" if match else "Fail ✗"
-                    })
-            
-            # Display results
-            df_results = pd.DataFrame(test_results)
-            
-            # Color coding
-            def color_result(val):
-                color = 'green' if val == "Pass ✓" else 'red'
-                return f'color: {color}; font-weight: bold'
-            
-            st.dataframe(
-                df_results.style.applymap(
-                    lambda x: color_result(x) if x in ["Pass ✓", "Fail ✗"] else ''
-                )
-            )
-            
-            # Calculate pass rate
-            pass_rate = (df_results["Result"] == "Pass ✓").mean()
-            st.metric("Validation Score", f"{pass_rate:.1%}", 
-                      delta=f"{len(test_cases)} tests", 
-                      delta_color="normal")
-
-# Single text analysis
-with st.form("analysis_form", clear_on_submit=False):
-    st.subheader("🔍 Text Analysis")
-    user_input = st.text_area("Enter text:", height=150, 
-                            value="The product quality is excellent but delivery was late")
-    submitted = st.form_submit_button("Analyze Sentiment", type="primary", use_container_width=True)
-    
-    if submitted and user_input.strip():
-        with st.spinner("Analyzing text..."):
-            label, confidence, processed_text, debug_info = predict_sentiment(user_input)
-            
-            # Save to history
-            st.session_state.analysis_history.insert(0, {
-                "text": user_input,
-                "label": label,
-                "confidence": confidence,
-                "timestamp": time.time()
-            })
-            
-            # Generate report
-            report = generate_sentiment_report(label, confidence, debug_info)
-            st.session_state.last_prediction = debug_info
-            
-            # Display results
-            sentiment_class = "success-box" if label == "1.0" else \
-                             "danger-box" if label == "-1.0" else "info-box"
-            
-            st.markdown(f"""
-            <div class="header-box {sentiment_class}">
-                <h2 style="margin:0;">{report['sentiment']}</h2>
-                <p style="font-size: 1.2rem; margin:0;">Confidence: <b>{report['confidence']}</b></p>
-            </div>
-            """, unsafe_allow_html=True)
-            
-            # Feature badges
-            if report["features"]:
-                st.subheader("Key Features Detected")
-                cols = st.columns(3)
-                for i, feature in enumerate(report["features"]):
-                    with cols[i % 3]:
-                        st.markdown(f"<div class='feature-badge feature-badge-default'>{feature}</div>", 
-                                   unsafe_allow_html=True)
-            
-            # Word cloud and probabilities
-            col1, col2 = st.columns(2)
-            with col1:
-                if report["word_cloud"]:
-                    st.subheader("Keyword Analysis")
-                    st.pyplot(report["word_cloud"])
-            
-            with col2:
-                st.subheader("Sentiment Probabilities")
-                if st.session_state.last_prediction and "probabilities" in st.session_state.last_prediction:
-                    prob_data = {
-                        "Negative": st.session_state.last_prediction['probabilities']["Negative"],
-                        "Neutral": st.session_state.last_prediction['probabilities']["Neutral"],
-                        "Positive": st.session_state.last_prediction['probabilities']["Positive"]
-                    }
-                    st.bar_chart(prob_data)
-                    
-                    # Confidence indicator
-                    st.metric("Confidence Level", report["confidence"], 
-                             delta="High confidence" if confidence > 0.8 else 
-                                   "Medium confidence" if confidence > 0.65 else "Low confidence")
-            
-            # Debug info
-            with st.expander("Analysis Details"):
-                st.write(f"**Processed Text:**")
-                st.code(processed_text)
-                
-                if st.session_state.last_prediction:
-                    st.write("**Debug Information:**")
-                    st.json(st.session_state.last_prediction)
-
-# --- CSV Batch Processing Section ---
-st.subheader("📊 Batch Analysis from CSV")
-st.write("Analyze large datasets by uploading a CSV file with text content")
-
-uploaded_file = st.file_uploader("Upload CSV file", type=["csv"], 
-                                help="File must contain a column named 'text'")
-
-if uploaded_file is not None:
-    try:
-        # Read CSV file
-        df = pd.read_csv(uploaded_file)
-        
-        # Verify required column exists
-        if 'text' not in df.columns:
-            st.error("❌ CSV file must contain a column named 'text'")
-            st.stop()
-            
-        st.success(f"✅ Successfully loaded {len(df)} records")
-        
-        with st.expander("Preview Data", expanded=True):
-            st.dataframe(df.head(3))
-        
-        # Process in batches
-        if st.button("Analyze Entire Dataset", type="primary", key="batch_analyze"):
-            results = []
-            sentiment_counts = Counter()
-            feature_counts = Counter()
-            
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-            status_placeholder = st.empty()
-            
-            # Process each row
-            for i, row in enumerate(df.itertuples()):
-                text = str(row.text)
-                label, confidence, _, debug_info = predict_sentiment(text)
-                
-                # Get sentiment name
-                sentiment_name = SENTIMENT_MAP[label]["name"]
-                sentiment_counts[sentiment_name] += 1
-                
-                # Count features
-                if debug_info and "features" in debug_info:
-                    for feature, present in debug_info["features"].items():
-                        if present:
-                            feature_counts[feature.replace('_', ' ').title()] += 1
-                
-                # Add to results
-                results.append({
-                    "Original Text": text,
-                    "Processed Text": debug_info.get("processed_text", ""),
-                    "Sentiment": sentiment_name,
-                    "Label": label,
-                    "Confidence": confidence,
-                    "Features": ", ".join([
-                        k.replace('_', ' ').title() 
-                        for k, v in debug_info.get("features", {}).items() 
-                        if v
-                    ])
-                })
-                
-                # Update progress
-                progress = (i + 1) / len(df)
-                progress_bar.progress(progress)
-                status_text.text(f"Processed {i+1}/{len(df)} records ({progress:.0%})")
-                
-                # Update every 50 records
-                if i % 50 == 0:
-                    with status_placeholder.container():
-                        st.caption(f"Current distribution: {dict(sentiment_counts)}")
-            
-            # Create results dataframe
-            results_df = pd.DataFrame(results)
-            
-            # Show summary
-            st.subheader("Analysis Summary")
-            col1, col2, col3 = st.columns(3)
-            
-            with col1:
-                st.metric("Total Records", len(df))
-                
-            with col2:
-                st.metric("Positive", f"{sentiment_counts['Positive']} ({sentiment_counts['Positive']/len(df):.1%})")
-                
-            with col3:
-                st.metric("Negative", f"{sentiment_counts['Negative']} ({sentiment_counts['Negative']/len(df):.1%})")
-            
-            # Sentiment distribution
-            st.subheader("Sentiment Distribution")
-            dist_col1, dist_col2 = st.columns([1, 2])
-            
-            with dist_col1:
-                st.dataframe(pd.DataFrame.from_dict(sentiment_counts, orient='index', columns=['Count']))
-            
-            with dist_col2:
-                st.bar_chart(pd.Series(sentiment_counts))
-            
-            # Feature prevalence
-            st.subheader("Feature Frequency")
-            if feature_counts:
-                feature_df = pd.DataFrame.from_dict(feature_counts, orient='index', columns=['Count'])
-                feature_df = feature_df.sort_values('Count', ascending=False)
-                st.dataframe(feature_df)
-            else:
-                st.info("No linguistic features detected in this dataset")
-            
-            # Show results table
-            st.subheader("Detailed Results")
-            st.dataframe(results_df)
-            
-            # Download results
-            csv = results_df.to_csv(index=False).encode('utf-8')
-            st.download_button(
-                label="Download Full Results as CSV",
-                data=csv,
-                file_name="sentiment_analysis_results.csv",
-                mime="text/csv",
-                type="primary"
-            )
-            
-    except Exception as e:
-        st.error(f"Error processing CSV file: {str(e)}")
-
-# Footer
-st.markdown("---")
-st.caption("Professional Sentiment Analysis System v3.0 | "
-          "© 2025 Sentiment Analytics Inc. | "
-          f"Model: Simplified LSTM with Attention")
+# [Keep the rest of your app.py UI code unchanged]