Update app.py

app.py

@@ -1,75 +1,87 @@
-import os
-import streamlit as st
+import dash
+from dash import dcc, html
+import plotly.express as px
+import plotly.graph_objects as go
 import pandas as pd
 import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-from wordcloud import WordCloud
+from datetime import datetime, timedelta
 from transformers import pipeline
 from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-from prophet import Prophet
+from sklearn.linear_model import LinearRegression
+from wordcloud import WordCloud
+import base64
+from io import BytesIO
 
-# Load sentiment analysis models
-vader = SentimentIntensityAnalyzer()
+# Initialize sentiment models
 bert_sentiment = pipeline("sentiment-analysis")
+vader_analyzer = SentimentIntensityAnalyzer()
 
-# Streamlit UI setup
-st.title("Sentiment Analysis & Prediction")
+# 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})
 
-# User input
-user_input = st.text_area("Enter text for sentiment analysis")
+# Train a regression model
+X = np.array(range(len(df))).reshape(-1, 1)
+y = df["Sentiment Score"]
+model = LinearRegression()
+model.fit(X, y)
 
-def analyze_sentiment(text):
-    """Perform sentiment analysis using VADER and BERT."""
-    vader_score = vader.polarity_scores(text)['compound']
-    bert_result = bert_sentiment(text)[0]
-    return vader_score, bert_result['label'], bert_result['score']
+# 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)
 
-# Process input
-if user_input:
-    vader_score, bert_label, bert_confidence = analyze_sentiment(user_input)
-    
-    # Display results
-    st.subheader("Sentiment Analysis Results")
-    st.write(f"**VADER Sentiment Score:** {vader_score}")
-    st.write(f"**BERT Sentiment:** {bert_label} ({bert_confidence:.2f})")
+future_df = pd.DataFrame({"Date": future_dates, "Predicted Sentiment": predictions})
+
+# Generate Word Cloud
+def generate_wordcloud(text):
+    wordcloud = WordCloud(width=800, height=400, background_color='white').generate(text)
+    img = BytesIO()
+    wordcloud.to_image().save(img, format='PNG')
+    return base64.b64encode(img.getvalue()).decode()
+
+# Dash app setup
+app = dash.Dash(__name__)
+app.layout = html.Div([
+    html.H1("Sentiment Analysis Dashboard", style={'textAlign': 'center', 'color': '#333'}),
+    html.Div([
+        dcc.Input(id='text_input', type='text', placeholder='Enter text here...', style={'width': '70%'}),
+        html.Button('Analyze', id='analyze_btn', style={'margin-left': '10px'})
+    ], style={'textAlign': 'center', 'margin-bottom': '20px'}),
     
-    # Word Cloud
-    st.subheader("Word Cloud of Input Text")
-    wordcloud = WordCloud(width=600, height=400, background_color='white').generate(user_input)
-    fig, ax = plt.subplots()
-    ax.imshow(wordcloud, interpolation='bilinear')
-    ax.axis("off")
-    st.pyplot(fig)
+    html.Div(id='sentiment_output', style={'fontSize': '20px', 'textAlign': 'center'}),
     
-    # Time Series Data for Prediction
-    days = 30
-    date_range = pd.date_range(start=pd.Timestamp.today(), periods=days, freq='D')
-    sentiment_scores = np.cumsum(np.random.randn(days) * 0.1 + vader_score)
-    df = pd.DataFrame({'ds': date_range, 'y': sentiment_scores})
+    dcc.Graph(id='sentiment_trend',
+              figure=px.line(df, x='Date', y='Sentiment Score', title='Past Sentiment Trends', markers=True, line_shape='spline')
+              ),
     
-    # Facebook Prophet Prediction
-    model = Prophet()
-    model.fit(df)
-    future = model.make_future_dataframe(periods=7)
-    forecast = model.predict(future)
+    dcc.Graph(id='future_trend',
+              figure=px.line(future_df, x='Date', y='Predicted Sentiment', title='Sentiment Prediction for Next 7 Days', markers=True, line_shape='spline')
+              ),
     
-    # Plot predictions
-    st.subheader("Sentiment Prediction for Next 7 Days")
-    fig, ax = plt.subplots()
-    ax.plot(forecast['ds'], forecast['yhat'], label='Predicted Sentiment', color='blue')
-    ax.fill_between(forecast['ds'], forecast['yhat_lower'], forecast['yhat_upper'], alpha=0.2, color='blue')
-    ax.axhline(0, color='black', linestyle='dashed')
-    ax.set_title("Sentiment Trend Prediction")
-    ax.set_xlabel("Date")
-    ax.set_ylabel("Sentiment Score")
-    ax.legend()
-    st.pyplot(fig)
+    dcc.Graph(id='sentiment_pie',
+              figure=px.pie(values=[sum(df['Sentiment Score'] > 0), sum(df['Sentiment Score'] <= 0)], 
+                           names=['Positive', 'Negative'], title='Sentiment Distribution', hole=0.3)
+              ),
     
-    # Explanation
-    st.subheader("What These Results Mean")
-    st.write("- **VADER Score:** Measures sentiment from -1 (negative) to +1 (positive)")
-    st.write("- **BERT Sentiment:** Deep learning-based classification")
-    st.write("- **Prediction Graph:** Expected sentiment trend for the next 7 days")
+    html.Img(id='wordcloud_img', style={'width': '50%', 'margin-top': '20px', 'display': 'block', 'margin-left': 'auto', 'margin-right': 'auto'})
+])
+
+@app.callback(
+    [dash.dependencies.Output('sentiment_output', 'children'),
+     dash.dependencies.Output('wordcloud_img', 'src')],
+    [dash.dependencies.Input('analyze_btn', 'n_clicks')],
+    [dash.dependencies.State('text_input', 'value')]
+)
+def analyze_sentiment(n_clicks, text):
+    if n_clicks:
+        vader_score = vader_analyzer.polarity_scores(text)['compound']
+        bert_result = bert_sentiment(text)[0]
+        explanation = f"VADER Score: {vader_score:.2f}, BERT Sentiment: {bert_result['label']} ({bert_result['score']:.2f})"
+        wordcloud_img = f'data:image/png;base64,{generate_wordcloud(text)}'
+        return explanation, wordcloud_img
+    return '', ''
 
-st.write("\n---\nBuilt with Streamlit, VADER, BERT, and Facebook Prophet 🚀")
+if __name__ == '__main__':
+    app.run_server(debug=True)