Update app.py

app.py

@@ -22,19 +22,218 @@ nltk.download('stopwords', quiet=True)
 # --- Custom Layers ---
 @tf.keras.utils.register_keras_serializable(package="CustomLayers")
 class FeatureExtractor(tf.keras.layers.Layer):
-    # Keep the same implementation from training code
+    def __init__(self, **kwargs):
+        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'
+        )
+        super(FeatureExtractor, self).build(input_shape)
+        
+    def call(self, inputs):
+        # Detect features
+        contrast = tf.tensordot(inputs, self.contrast_kernel, axes=1)
+        contrast = tf.squeeze(contrast, axis=-1)
+        
+        negation = tf.tensordot(inputs, self.negation_kernel, axes=1)
+        negation = tf.squeeze(negation, axis=-1)
+        
+        intensifier = tf.tensordot(inputs, self.intensifier_kernel, axes=1)
+        intensifier = tf.squeeze(intensifier, axis=-1)
+        
+        # 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)
 
 @tf.keras.utils.register_keras_serializable(package="CustomLayers")
 class SentimentAdjuster(tf.keras.layers.Layer):
-    # Keep the same implementation from training code
+    def __init__(self, **kwargs):
+        super(SentimentAdjuster, self).__init__(**kwargs)
+        
+    def build(self, input_shape):
+        self.contrast_weight = self.add_weight(
+            name='contrast_weight',
+            shape=(3,),
+            initializer='zeros'
+        )
+        self.negation_weight = self.add_weight(
+            name='negation_weight',
+            shape=(3,),
+            initializer='zeros'
+        )
+        super(SentimentAdjuster, self).build(input_shape)
+        
+    def call(self, inputs):
+        predictions, features = inputs
+        
+        # Aggregate features (max pooling)
+        contrast_features = tf.reduce_max(features[..., 0], axis=1)
+        negation_features = tf.reduce_max(features[..., 1], axis=1)
+        intensifier_features = tf.reduce_max(features[..., 2], axis=1)
+        
+        # Rule 1: Contrast adjustment
+        contrast_mask = tf.cast(contrast_features > 0.5, tf.float32)
+        contrast_adjustment = contrast_mask * self.contrast_weight[0]
+        
+        # Rule 2: Negation adjustment
+        negation_mask = tf.cast(negation_features > 0.5, tf.float32)
+        negation_adjustment = negation_mask * self.negation_weight[0]
+        
+        # Rule 3: Intensifier adjustment
+        intensifier_mask = tf.cast(intensifier_features > 0.5, tf.float32)
+        intensifier_adjustment = intensifier_mask * self.contrast_weight[1]
+        
+        # Combine adjustments
+        total_adjustment = contrast_adjustment + negation_adjustment + intensifier_adjustment
+        
+        # Create adjustment matrix
+        adjustment_matrix = tf.stack([
+            total_adjustment * self.contrast_weight[2],  # Positive adjustment
+            tf.zeros_like(total_adjustment),              # Neutral adjustment
+            -total_adjustment * self.negation_weight[1]  # Negative adjustment
+        ], axis=1)
+        
+        # Apply adjustments
+        adjusted = predictions + adjustment_matrix
+        
+        # Ensure valid probabilities
+        adjusted = tf.clip_by_value(adjusted, 1e-7, 1 - 1e-7)
+        adjusted = adjusted / tf.reduce_sum(adjusted, axis=1, keepdims=True)
+        
+        return adjusted
+
+    def compute_output_shape(self, input_shape):
+        return input_shape[0]
 
 @tf.keras.utils.register_keras_serializable(package="CustomLayers")
 class SimpleAttention(tf.keras.layers.Layer):
-    # Keep the same implementation from training code
+    def __init__(self, **kwargs):
+        super(SimpleAttention, self).__init__(**kwargs)
+
+    def build(self, input_shape):
+        self.W = self.add_weight(
+            name="attention_weight",
+            shape=(input_shape[-1], 1),
+            initializer="glorot_uniform",
+            trainable=True
+        )
+        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)
+        context = inputs * alpha
+        return tf.keras.backend.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):
-    # Keep the same implementation from training code
+    if not isinstance(text, str) or not text.strip():
+        return ""
+
+    try:
+        # Handle neutral/negation phrases
+        neutral_phrases = [
+            'not bad', 'not great', 'okay', 'so-so', 'meh', 'average', 
+            'mediocre', 'acceptable', 'tolerable', 'passable', 'decent',
+            'nothing special', 'middle of the road', 'run of the mill'
+        ]
+        for phrase in neutral_phrases:
+            text = re.sub(r'\b' + re.escape(phrase) + r'\b', ' neutral_term ', text, flags=re.IGNORECASE)
+        
+        # Enhanced negation handling
+        negation_patterns = [
+            r'\b(not|no|never|without|nobody|none|nothing|nowhere|neither|nor)\b [\w]+',
+            r'\b(less than|barely|hardly|scarcely|rarely|seldom)\b [\w]+',
+            r'\b(avoid|skip|doubt|problem|issue|complaint|warning|caution|refuse)\b',
+            r'\b(despite|in spite of|regardless|although|even though)\b'
+        ]
+        for pattern in negation_patterns:
+            text = re.sub(pattern, ' negation_term ', text, flags=re.IGNORECASE)
+        
+        # Emoji handling
+        text = emoji.demojize(text, delimiters=("", ""))
+        
+        # Contractions
+        text = contractions.fix(text)
+        
+        # URL/mention replacement
+        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()
+        
+        # Emoticon preservation
+        emoticons = re.findall(r'(?::|;|=)(?:-)?(?:\)|\(|D|P)', text)
+        text = re.sub(r'[^\w\s!?.,]', ' ', text)
+        
+        # Tokenization with advanced handling
+        tokens = word_tokenize(text)
+        processed_tokens = []
+        
+        # Contextual sentiment indicators
+        contextual_indicators = {
+            'but': 'contrast_indicator',
+            'however': 'contrast_indicator',
+            'although': 'contrast_indicator',
+            'except': 'contrast_indicator',
+            'unless': 'contrast_indicator',
+            'yet': 'contrast_indicator',
+            'still': 'contrast_indicator',
+            'nonetheless': 'contrast_indicator',
+            'very': 'intensifier',
+            'extremely': 'intensifier',
+            'absolutely': 'intensifier',
+            'completely': 'intensifier',
+            'utterly': 'intensifier',
+            'slightly': 'diminisher',
+            'somewhat': 'diminisher',
+            'barely': 'diminisher',
+            'marginally': 'diminisher',
+            'almost': 'diminisher',
+            'only': 'diminisher',
+            'wow': 'positive_exclamation',
+            'awesome': 'positive_exclamation',
+            'ugh': 'negative_exclamation',
+            'yuck': 'negative_exclamation'
+        }
+        
+        for token in tokens:
+            if not token.strip():
+                continue
+                
+            # Handle contextual indicators
+            if token in contextual_indicators:
+                processed_tokens.append(contextual_indicators[token])
+                continue
+                
+            processed_tokens.append(token)
+                
+        processed_tokens.extend(emoticons)
+        return ' '.join(processed_tokens)
+
+    except Exception:
+        return text.lower()
+
 
 # --- Load model resources ---
 @st.cache_resource