Update app.py

app.py

@@ -1,130 +1,120 @@
 import streamlit as st
-import pandas as pd
+from transformers import pipeline
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 import numpy as np
-from datetime import datetime
+import pandas as pd
+from datetime import datetime, timedelta
 import plotly.express as px
-import plotly.graph_objects as go
 from sklearn.linear_model import LinearRegression
-from sklearn.ensemble import RandomForestRegressor
-from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
-from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-from wordcloud import WordCloud, STOPWORDS
-import matplotlib.pyplot as plt
-from io import BytesIO
+from wordcloud import WordCloud
 import base64
-import nltk
-from nltk.corpus import stopwords
-from nltk.tokenize import word_tokenize
-from nltk.stem import WordNetLemmatizer
-import re
-from textblob import TextBlob
-
-# Ensure necessary NLTK resources are downloaded
-nltk_resources = ['punkt', 'stopwords', 'wordnet']
-for resource in nltk_resources:
-    try:
-        nltk.data.find(f'corpora/{resource}')
-    except LookupError:
-        nltk.download(resource)
-
-# Streamlit Page Configuration
-st.set_page_config(
-    page_title="SentiMind Pro - Advanced Sentiment Analysis",
-    page_icon="📊",
-    layout="wide"
-)
+from io import BytesIO
 
-# Initialize Sentiment Analysis Models
-@st.cache_resource()
-def load_models():
-    sentiment_models = {
-        'vader': SentimentIntensityAnalyzer(),
-        'textblob': TextBlob
-    }
-    
-    try:
-        model_name = "distilbert-base-uncased-finetuned-sst-2-english"
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        model = AutoModelForSequenceClassification.from_pretrained(model_name)
-        sentiment_models['bert'] = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
-    except Exception as e:
-        st.warning(f"Could not load BERT model: {e}")
-        sentiment_models['bert'] = None
-    
-    return sentiment_models
+# Initialize sentiment models
+bert_sentiment = pipeline("sentiment-analysis")
+vader_analyzer = SentimentIntensityAnalyzer()
 
-models = load_models()
+# Generate sample past sentiment data
+dates = [datetime.today() - timedelta(days=i) for i in range(14)]
+sentiment_scores = np.random.uniform(-1, 1, len(dates))
+df = pd.DataFrame({"Date": dates, "Sentiment Score": sentiment_scores})
 
-# Text Preprocessing Function
-def preprocess_text(text):
-    text = text.lower()
-    text = re.sub(r'http\S+|www\S+', '', text)  # Remove URLs
-    text = re.sub(r'@\w+|#\w+', '', text)  # Remove mentions and hashtags
-    text = re.sub(r'[^\w\s]', '', text)  # Remove punctuation
-    text = re.sub(r'\s+', ' ', text).strip()  # Remove extra spaces
-    
-    tokens = word_tokenize(text)
-    stop_words = set(stopwords.words('english'))
-    tokens = [word for word in tokens if word not in stop_words]
-    
-    lemmatizer = WordNetLemmatizer()
-    tokens = [lemmatizer.lemmatize(word) for word in tokens]
-    
-    return ' '.join(tokens)
+# Train a regression model
+X = np.array(range(len(df))).reshape(-1, 1)
+y = df["Sentiment Score"]
+model = LinearRegression()
+model.fit(X, y)
 
-# Sentiment Analysis Function
-def analyze_sentiment(text):
-    processed_text = preprocess_text(text)
-    vader_score = models['vader'].polarity_scores(text)['compound']
-    
-    if models['bert']:
-        bert_result = models['bert'](text)[0]
-        bert_score = bert_result['score'] if bert_result['label'] == 'POSITIVE' else -bert_result['score']
-    else:
-        bert_score = 0
-    
-    textblob_score = models['textblob'](text).sentiment.polarity
-    combined_score = (0.4 * vader_score + 0.4 * bert_score + 0.2 * textblob_score)
-    
-    return {
-        'vader': vader_score,
-        'bert': bert_score,
-        'textblob': textblob_score,
-        'combined': combined_score
-    }
-
-# Word Cloud Generation
+# Predict for next 7 days
+future_dates = [datetime.today() + timedelta(days=i) for i in range(1, 8)]
+X_future = np.array(range(len(df), len(df) + 7)).reshape(-1, 1)
+predictions = model.predict(X_future)
+
+future_df = pd.DataFrame({"Date": future_dates, "Predicted Sentiment": predictions})
+
+# Generate Word Cloud
 def generate_wordcloud(text):
-    stopwords_set = set(STOPWORDS)
-    wordcloud = WordCloud(width=800, height=400, stopwords=stopwords_set, background_color='white').generate(text)
-    
+    wordcloud = WordCloud(width=800, height=400, background_color='white').generate(text)
     img = BytesIO()
-    plt.figure(figsize=(10, 5))
-    plt.imshow(wordcloud, interpolation='bilinear')
-    plt.axis('off')
-    plt.savefig(img, format='PNG', bbox_inches='tight')
-    plt.close()
-    
+    wordcloud.to_image().save(img, format='PNG')
     return base64.b64encode(img.getvalue()).decode()
 
-# Streamlit UI
-def main():
-    st.title("📊 SentiMind Pro - Advanced Sentiment Analysis")
-    st.subheader("Analyze text sentiment using multiple models!")
-    
-    user_input = st.text_area("Enter your text for sentiment analysis:")
+# Streamlit app setup
+st.title("Interactive Sentiment Analysis Dashboard")
+
+# Sidebar for navigation and settings
+st.sidebar.header("Sentiment Analysis Controls")
+st.sidebar.subheader("Input")
+user_input = st.sidebar.text_input('Enter text for sentiment analysis')
+
+# Display sentiment analysis results
+def display_sentiment_analysis(vader_score, bert_result):
+    st.subheader("Sentiment Analysis Results:")
+    st.write(f"**VADER Sentiment Score**: {vader_score:.2f}")
+    st.write(f"**BERT Sentiment**: {bert_result['label']} ({bert_result['score']:.2f})")
     
-    if st.button("Analyze Sentiment") and user_input:
-        with st.spinner("Analyzing..."):
-            sentiment_results = analyze_sentiment(user_input)
-            
-            st.metric("VADER Sentiment", f"{sentiment_results['vader']:.2f}")
-            st.metric("BERT Sentiment", f"{sentiment_results['bert']:.2f}")
-            st.metric("TextBlob Sentiment", f"{sentiment_results['textblob']:.2f}")
-            st.metric("Combined Sentiment Score", f"{sentiment_results['combined']:.2f}")
-            
-            wordcloud_img = generate_wordcloud(user_input)
-            st.image(f"data:image/png;base64,{wordcloud_img}", caption="Word Cloud", use_column_width=True)
+    sentiment_data = {'Positive': max(0, vader_score), 'Negative': min(0, vader_score), 'Neutral': 1 - abs(vader_score)}
+    sentiment_df = pd.DataFrame(list(sentiment_data.items()), columns=["Sentiment", "Score"])
+    st.bar_chart(sentiment_df.set_index("Sentiment"))
     
-if __name__ == "__main__":
-    main()
+    wordcloud_img = f'data:image/png;base64,{generate_wordcloud(user_input)}'
+    st.image(wordcloud_img, use_column_width=True)
+
+# Analyze sentiment on button click
+if st.sidebar.button('Analyze Sentiment'):
+    if user_input:
+        with st.spinner('Analyzing text...'):
+            vader_score = vader_analyzer.polarity_scores(user_input)['compound']
+            bert_result = bert_sentiment(user_input)[0]
+            display_sentiment_analysis(vader_score, bert_result)
+    else:
+        st.warning("Please enter some text for analysis.")
+
+# Past sentiment trends
+st.subheader("Past Sentiment Trends (Last 14 Days)")
+fig1 = px.line(df, x='Date', y='Sentiment Score', title='Past Sentiment Trends', markers=True, line_shape='spline')
+st.plotly_chart(fig1)
+
+# Future sentiment predictions
+st.subheader("Sentiment Prediction for Next 7 Days")
+fig2 = px.line(future_df, x='Date', y='Predicted Sentiment', title='Sentiment Prediction for Next 7 Days', markers=True, line_shape='spline')
+st.plotly_chart(fig2)
+
+# Sentiment distribution pie chart
+st.subheader("Sentiment Distribution")
+fig3 = px.pie(values=[sum(df['Sentiment Score'] > 0), sum(df['Sentiment Score'] <= 0)], 
+              names=['Positive', 'Negative'], title='Sentiment Distribution', hole=0.3)
+st.plotly_chart(fig3)
+
+# Histogram of Sentiment Scores
+st.subheader("Sentiment Score Distribution (Past 14 Days)")
+fig4 = px.histogram(df, x='Sentiment Score', nbins=20, title="Sentiment Score Distribution")
+st.plotly_chart(fig4)
+
+# Sentiment heatmap (corrected version)
+st.subheader("Sentiment Heatmap (Past 14 Days)")
+df['Day'] = df['Date'].dt.dayofweek  # Monday=0, Sunday=6
+df['Hour'] = np.random.randint(0, 24, len(df))  # Simulating hourly data
+heatmap_data = df.pivot(index='Day', columns='Hour', values='Sentiment Score')
+fig5 = px.imshow(
+    heatmap_data, 
+    title="Heatmap of Sentiment Over Time", 
+    labels={'x': 'Hour of Day', 'y': 'Day of Week'}, 
+    color_continuous_scale='RdBu'
+)
+st.plotly_chart(fig5)
+
+# Sentiment scatter plot
+st.subheader("Sentiment Scatter Plot (Past 14 Days)")
+fig6 = px.scatter(df, x='Date', y='Sentiment Score', title='Sentiment Over Time')
+st.plotly_chart(fig6)
+
+# Rolling average sentiment
+st.subheader("Rolling Average of Sentiment (7-Day Window)")
+df['Rolling Avg Sentiment'] = df['Sentiment Score'].rolling(window=7).mean()
+fig7 = px.line(df, x='Date', y='Rolling Avg Sentiment', title="Rolling Average of Sentiment (7-Day Window)")
+st.plotly_chart(fig7)
+
+# Reset button
+if st.sidebar.button('Reset Analysis'):
+    st.experimental_rerun()