Update app.py

app.py

@@ -1,12 +1,12 @@
 import os
-os.environ["CUDA_VISIBLE_DEVICES"] = "-1"  # Disable GPU
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1"  
 
 import gradio as gr
 import numpy as np
 from tensorflow.keras.models import load_model
 from tensorflow.keras.preprocessing.sequence import pad_sequences
 import pickle
-import re  # Added for text preprocessing
+import re
 
 # Load your models
 gru_model = load_model("best_GRU_tuning_model.h5")
@@ -17,97 +17,123 @@ bilstm_model = load_model("BiLSTM_model.h5")
 with open("my_tokenizer.pkl", "rb") as f:
     tokenizer = pickle.load(f)
 
-# Preprocess text
+# Preprocessing function for GRU, LSTM, and BiLSTM
 def preprocess_text(text):
     text = text.lower()
-    text = re.sub(r'[^a-zA-Z\s]', '', text).strip()
+    text = re.sub(r"[^a-zA-Z\s]", "", text).strip()
     return text
 
-# Predict sentiment using a model
-def predict_sentiment(model, text):
-    if not text or not text.strip():  # Check for empty input
-        return 0, [0, 0, 0, 0, 0]  # Return default values for empty input
-    
+# GRU prediction function
+def predict_with_gru(text):
     cleaned = preprocess_text(text)
-    if not cleaned:  # Check if cleaned text is empty
-        return 0, [0, 0, 0, 0, 0]  # Return default values for invalid input
-    
     seq = tokenizer.texts_to_sequences([cleaned])
-    if not seq or not seq[0]:  # Check if tokenization failed
-        return 0, [0, 0, 0, 0, 0]  # Return default values for invalid input
-    
-    padded_seq = pad_sequences(seq, maxlen=200)
-    probs = model.predict(padded_seq)
+    padded_seq = pad_sequences(seq, maxlen=200)  
+    probs = gru_model.predict(padded_seq)
     predicted_class = np.argmax(probs, axis=1)[0]
-    rating = predicted_class + 1
-    return rating, probs[0]
+    return int(predicted_class + 1)
 
-# Main prediction function
-def predict_all_models(text):
-    try:
-        # Predict with GRU
-        gru_rating, gru_probs = predict_sentiment(gru_model, text)
-        # Predict with LSTM
-        lstm_rating, lstm_probs = predict_sentiment(lstm_model, text)
-        # Predict with BiLSTM
-        bilstm_rating, bilstm_probs = predict_sentiment(bilstm_model, text)
-        
-        # Calculate statistics
-        ratings = [gru_rating, lstm_rating, bilstm_rating]
-        lowest = min(ratings)
-        highest = max(ratings)
-        average = sum(ratings) / len(ratings)
-        
-        # Format results
-        results = {
-            "GRU Model": f"Predicted Rating: {gru_rating} (Probabilities: {gru_probs})",
-            "LSTM Model": f"Predicted Rating: {lstm_rating} (Probabilities: {lstm_probs})",
-            "BiLSTM Model": f"Predicted Rating: {bilstm_rating} (Probabilities: {bilstm_probs})",
-            "Statistics": f"Lowest: {lowest}, Highest: {highest}, Average: {average:.2f}"
+# LSTM prediction function
+def predict_with_lstm(text):
+    cleaned = preprocess_text(text)
+    seq = tokenizer.texts_to_sequences([cleaned])
+    padded_seq = pad_sequences(seq, maxlen=200) 
+    probs = lstm_model.predict(padded_seq)
+    predicted_class = np.argmax(probs, axis=1)[0]
+    return int(predicted_class + 1)
+
+# BiLSTM prediction function
+def predict_with_bilstm(text):
+    cleaned = preprocess_text(text)
+    seq = tokenizer.texts_to_sequences([cleaned])
+    padded_seq = pad_sequences(seq, maxlen=200)  
+    probs = bilstm_model.predict(padded_seq)
+    predicted_class = np.argmax(probs, axis=1)[0]
+    return int(predicted_class + 1)
+
+# Unified function for sentiment analysis and statistics
+def analyze_sentiment_and_statistics(text):
+    results = {
+        "GRU Model": predict_with_gru(text),
+        "LSTM Model": predict_with_lstm(text),
+        "BiLSTM Model": predict_with_bilstm(text),
+    }
+    
+    # Calculate statistics
+    scores = list(results.values())
+    min_score = min(scores)
+    max_score = max(scores)
+    min_score_models = [model for model, score in results.items() if score == min_score]
+    max_score_models = [model for model, score in results.items() if score == max_score]
+    average_score = np.mean(scores)
+
+    if all(score == scores[0] for score in scores):
+        statistics = {
+            "Message": "All models predict the same score.",
+            "Average Score": f"{average_score:.2f}",
         }
-    except Exception as e:
-        print(f"Error during prediction: {e}")  # Debugging: Print the error
-        results = {
-            "GRU Model": "Error",
-            "LSTM Model": "Error",
-            "BiLSTM Model": "Error",
-            "Statistics": "Error"
+    else:
+        statistics = {
+            "Lowest Score": f"{min_score} (Models: {', '.join(min_score_models)})",
+            "Highest Score": f"{max_score} (Models: {', '.join(max_score_models)})",
+            "Average Score": f"{average_score:.2f}",
         }
-    
-    return results
+    return results, statistics
 
-# Gradio interface
-def create_interface():
-    with gr.Blocks() as demo:
-        gr.Markdown("# Sentiment Analysis App")
-        gr.Markdown("Predict the sentiment of your text review using RNN-based models.")
-        
-        with gr.Row():
-            text_input = gr.Textbox(label="Enter your text here:", placeholder="Type your review here...")
-        
-        with gr.Row():
-            gr.Markdown("### Predicted Sentiment")
-            gru_output = gr.Textbox(label="GRU Model")
-            lstm_output = gr.Textbox(label="LSTM Model")
-            bilstm_output = gr.Textbox(label="BiLSTM Model")
-        
-        with gr.Row():
-            gr.Markdown("### Statistics")
-            stats_output = gr.Textbox(label="Lowest, Highest, Average")
+# Gradio Interface
+with gr.Blocks(css=".gradio-container { max-width: 900px; margin: auto; padding: 20px; }") as demo:
+    gr.Markdown("# RNN Sentiment Analysis")
+    gr.Markdown(
+        "Predict the sentiment of your text review using RNN-based models."
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(
+                label="Enter your text here:", 
+                lines=3, 
+                placeholder="Type your review here..."
+            )
         
-        # Button to predict
-        predict_button = gr.Button("Predict Sentiment")
+        with gr.Column():
+            analyze_button = gr.Button("Analyze Sentiment")
+
+    with gr.Row():
+        with gr.Column():
+            gru_output = gr.Textbox(label="Predicted Sentiment (GRU Model)", interactive=False)
+            lstm_output = gr.Textbox(label="Predicted Sentiment (LSTM Model)", interactive=False)
+            bilstm_output = gr.Textbox(label="Predicted Sentiment (BiLSTM Model)", interactive=False)
         
-        # Event handler for the predict button
-        predict_button.click(
-            fn=predict_all_models,
-            inputs=text_input,
-            outputs=[gru_output, lstm_output, bilstm_output, stats_output]
-        )
+        with gr.Column():
+            statistics_output = gr.Textbox(label="Statistics (Lowest, Highest, Average)", interactive=False)
+
+    # Button to analyze sentiment and show statistics
+    def process_input_and_analyze(text_input):
+        results, statistics = analyze_sentiment_and_statistics(text_input)
+        if "Message" in statistics:
+            return (
+                f"{results['GRU Model']}",
+                f"{results['LSTM Model']}",
+                f"{results['BiLSTM Model']}",
+                f"Statistics:\n{statistics['Message']}\nAverage Score: {statistics['Average Score']}"
+            )
+        else:
+            return (
+                f"{results['GRU Model']}",
+                f"{results['LSTM Model']}",
+                f"{results['BiLSTM Model']}",
+                f"Statistics:\n{statistics['Lowest Score']}\n{statistics['Highest Score']}\nAverage Score: {statistics['Average Score']}"
+            )
     
-    return demo
+    analyze_button.click(
+        process_input_and_analyze,
+        inputs=[text_input],
+        outputs=[
+            gru_output,
+            lstm_output, 
+            bilstm_output, 
+            statistics_output
+        ]
+    )
 
 # Launch the app
-if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch()
+demo.launch()