Update app.py

app.py

@@ -1,97 +1,128 @@
+import pandas as pd
+import numpy as np
 import streamlit as st
+import altair as alt
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from PIL import Image
+import base64
 
-# Define the model names or identifiers
-model1_name = "saisi/finetuned-Sentiment-classfication-ROBERTA-model"
-model2_name = "saisi/finetuned-Sentiment-classfication-DISTILBERT-model"
-
-# Initialize the tokenizer and models for sentiment analysis
-tokenizer1 = AutoTokenizer.from_pretrained(model1_name)
-model1 = AutoModelForSequenceClassification.from_pretrained(model1_name)
-tokenizer2 = AutoTokenizer.from_pretrained(model2_name)
-model2 = AutoModelForSequenceClassification.from_pretrained(model2_name)
-
-# Define a function to preprocess the text data
-def preprocess(text):
-    new_text = []
-    # Replace user mentions with '@user'
-    for t in text.split(" "):
-        t = '@user' if t.startswith('@') and len(t) > 1 else t
-        # Replace links with 'http'
-        t = 'http' if t.startswith('http') else t
-        new_text.append(t)
-    # Join the preprocessed text
-    return " ".join(new_text)
-
-# Define a function to perform sentiment analysis on the input text using model 1
-def sentiment_analysis_model1(text):
-    # Preprocess the input text
-    text = preprocess(text)
-
-    # Tokenize the input text using the pre-trained tokenizer
-    encoded_input = tokenizer1(text, return_tensors='pt')
-    
-    # Feed the tokenized input to the pre-trained model and obtain output
-    output = model1(**encoded_input)
-    
-    # Obtain the prediction scores for the output
-    scores_ = output[0][0].detach().numpy()
-    
-    # Apply softmax activation function to obtain probability distribution over the labels
-    scores_ = torch.nn.functional.softmax(torch.from_numpy(scores_), dim=0).numpy()
+# Define the "How to Use" message
+how_to_use = """
+**How to Use**
+1. Select a model from the dropdown menu
+2. Enter text in the text area
+3. Click the 'Analyze' button to get the predicted sentiment of the text
+"""
+image1 = Image.open("sentiment analysis.jpg")
+
+# Functions
+def main():
     
-    # Format the output dictionary with the predicted scores
-    labels = ['Negative', 'Positive']
-    scores = {l:float(s) for (l,s) in zip(labels, scores_) }
+    st.title("Covid Tweets Sentiment Analysis NLP App")
+    st.subheader("Team Harmony Project")
     
-    # Return the scores
-    return scores
 
-# Define a function to perform sentiment analysis on the input text using model 2
-def sentiment_analysis_model2(text):
-    # Preprocess the input text
-    text = preprocess(text)
+    # Open the image file
+    st.image(image1)
 
-    # Tokenize the input text using the pre-trained tokenizer
-    encoded_input = tokenizer2(text, return_tensors='pt')
-    
-    # Feed the tokenized input to the pre-trained model and obtain output
-    output = model2(**encoded_input)
-    
-    # Obtain the prediction scores for the output
-    scores_ = output[0][0].detach().numpy()
-    
-    # Apply softmax activation function to obtain probability distribution over the labels
-    scores_ = torch.nn.functional.softmax(torch.from_numpy(scores_), dim=0).numpy()
-    
-    # Format the output dictionary with the predicted scores
-    labels = ['Negative', 'Neutral', 'Positive']
-    scores = {l:float(s) for (l,s) in zip(labels, scores_) }
+    # Define the available models
+    models= {
+    "RoBERTa":"saisi/finetuned-Sentiment-classfication-ROBERTA-model",
+    "DistilBERT":"saisi/finetuned-Sentiment-classfication-DISTILBERT-model"
+}
     
-    # Return the scores
-    return scores
-
-# Define the Streamlit app
-def app():
-    # Define the app title
-    st.title("Sentiment Analysis")
-
-    # Define the input field
-    text_input = st.text_input("Enter text:")
-
-    # Define the model selection dropdown
-    model_selection = st.selectbox("Select a model:", ["Model 1", "Model 2"])
-
-    # Perform sentiment analysis when the submit button is clicked
-    if st.button("Submit"):
-        if text_input:
-            if model_selection == "Model 1":
-                # Perform sentiment analysis using model 1
-                scores = sentiment_analysis_model1(text_input)
-                st.write(f"Model 1 predicted scores: {scores}")
-            else:
-                # Perform sentiment analysis using model 2
-                scores = sentiment_analysis_model2(text_input)
-                st.write(f"Model 2 predicted scores: {scores}")
-        else:
-            st.warning("Please enter some text to perform sentiment analysis.")
+    menu = ["Home", "About"]
+    choice = st.sidebar.selectbox("Menu", menu)
+
+    # Add the "How to Use" message to the sidebar
+    st.sidebar.markdown(how_to_use)
+
+    if choice == "Home":
+        st.subheader("Home")
+
+        # Add a dropdown menu to select the model
+        model_name = st.selectbox("Select a model", list(models.keys()))
+
+        with st.form(key="nlpForm"):
+            raw_text = st.text_area("Enter Text Here")
+            submit_button = st.form_submit_button(label="Analyze")
+
+        # Layout
+        col1, col2 = st.columns(2)
+        if submit_button:
+            # Display balloons
+            st.balloons()
+            with col1:
+                st.info("Results")
+                tokenizer = AutoTokenizer.from_pretrained(models[model_name])
+                model = AutoModelForSequenceClassification.from_pretrained(models[model_name])
+
+                # Tokenize the input text
+                inputs = tokenizer(raw_text, return_tensors="pt")
+
+                # Make a forward pass through the model
+                outputs = model(**inputs)
+
+                # Get the predicted class and associated score
+                predicted_class = outputs.logits.argmax().item()
+                score = outputs.logits.softmax(dim=1)[0][predicted_class].item()
+
+                # Compute the scores for all sentiments
+                positive_score = outputs.logits.softmax(dim=1)[0][2].item()
+                negative_score = outputs.logits.softmax(dim=1)[0][0].item()
+                neutral_score = outputs.logits.softmax(dim=1)[0][1].item()
+
+                # Compute the confidence level
+                confidence_level = np.max(outputs.logits.detach().numpy())
+
+                # Print the predicted class and associated score
+                st.write(f"Predicted class: {predicted_class}, Score: {score:.3f}, Confidence Level: {confidence_level:.2f}")
+
+                # Emoji
+                if predicted_class == 2:
+                    st.markdown("Sentiment: Positive :smiley:")
+                    st.image(image2)
+                elif predicted_class == 1:
+                    st.markdown("Sentiment: Neutral :😐:")
+                    st.image(image3)
+                else:
+                    st.markdown("Sentiment: Negative :angry:")
+                    st.image(image4)
+
+            # Create the results DataFrame
+            # Define an empty DataFrame with columns
+
+            results_df = pd.DataFrame(columns=["Sentiment Class", "Score"])
+
+            # Create a DataFrame with scores for all sentiments
+            all_scores_df = pd.DataFrame({
+            'Sentiment Class': ['Positive', 'Negative', 'Neutral'],
+            'Score': [positive_score, negative_score, neutral_score]
+            })
+
+            # Concatenate the two DataFrames
+
+            results_df = pd.concat([results_df, all_scores_df], ignore_index=True)
+
+            
+
+            # Create the Altair chart
+            chart = alt.Chart(results_df).mark_bar(width=50).encode(
+                x="Sentiment Class",
+                y="Score",
+                color="Sentiment Class"
+            )
+
+            # Display the chart
+            with col2:
+                st.altair_chart(chart, use_container_width=True)
+                st.write(results_df)
+
+    else:
+        st.subheader("About")
+        st.write("This is a sentiment analysis NLP app developed by Team Harmony for analyzing tweets related to Covid-19.It uses a pre-trained model to predict the sentiment of the input text. The app is part of a project to promote teamwork and collaboration among developers.")
+
+
+
+if __name__ == "__main__":
+    main()