Update app.py

app.py

@@ -6,6 +6,9 @@ import pandas as pd
 from datetime import datetime, timedelta
 import plotly.express as px
 from sklearn.linear_model import Ridge
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_absolute_error
 from wordcloud import WordCloud
 import base64
 from io import BytesIO
@@ -14,6 +17,8 @@ from textblob import TextBlob
 import praw
 from googleapiclient.discovery import build
 import os
+from statsmodels.tsa.arima.model import ARIMA
+from prophet import Prophet
 
 # --------------------------
 # Initial Setup & Configuration
@@ -21,7 +26,7 @@ import os
 
 # Set page config
 st.set_page_config(
-    page_title="🌟 SentimentSync: Live Sentiment Analysis Dashboard",
+    page_title="🌟 SentimentSync: Live Sentiment Analysis & Prediction Dashboard",
     page_icon="📊",
     layout="wide"
 )
@@ -141,6 +146,149 @@ def generate_wordcloud(text):
         st.error(f"Error generating word cloud: {str(e)}")
         return ""
 
+def prepare_time_series_data(df):
+    """Prepare time series data for forecasting"""
+    try:
+        # Resample to daily data
+        ts_df = df.set_index('date').resample('D').agg({
+            'Average': 'mean',
+            'VADER': 'mean',
+            'BERT': 'mean',
+            'TextBlob': 'mean'
+        }).ffill().reset_index()
+        
+        # Create features
+        ts_df['day_of_week'] = ts_df['date'].dt.dayofweek
+        ts_df['day_of_month'] = ts_df['date'].dt.day
+        ts_df['days_since_start'] = (ts_df['date'] - ts_df['date'].min()).dt.days
+        
+        return ts_df
+    except Exception as e:
+        st.error(f"Error preparing time series data: {str(e)}")
+        return None
+
+def predict_sentiment_prophet(df, periods=15):
+    """Predict future sentiment using Facebook Prophet"""
+    try:
+        # Prepare data for Prophet
+        prophet_df = df[['date', 'Average']].rename(columns={'date': 'ds', 'Average': 'y'})
+        
+        # Initialize and fit model
+        model = Prophet(
+            daily_seasonality=True,
+            weekly_seasonality=True,
+            yearly_seasonality=False
+        )
+        model.fit(prophet_df)
+        
+        # Make future dataframe
+        future = model.make_future_dataframe(periods=periods)
+        
+        # Predict
+        forecast = model.predict(future)
+        
+        return forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].rename(columns={
+            'ds': 'date',
+            'yhat': 'predicted_sentiment',
+            'yhat_lower': 'lower_bound',
+            'yhat_upper': 'upper_bound'
+        })
+    except Exception as e:
+        st.error(f"Error with Prophet prediction: {str(e)}")
+        return None
+
+def predict_sentiment_arima(df, periods=15):
+    """Predict future sentiment using ARIMA"""
+    try:
+        # Fit ARIMA model
+        model = ARIMA(df['Average'], order=(2, 1, 2))
+        model_fit = model.fit()
+        
+        # Make predictions
+        forecast = model_fit.forecast(steps=periods)
+        
+        # Create future dates
+        last_date = df['date'].max()
+        future_dates = [last_date + timedelta(days=i) for i in range(1, periods+1)]
+        
+        return pd.DataFrame({
+            'date': future_dates,
+            'predicted_sentiment': forecast,
+            'model': 'ARIMA'
+        })
+    except Exception as e:
+        st.error(f"Error with ARIMA prediction: {str(e)}")
+        return None
+
+def predict_sentiment_rf(df, periods=15):
+    """Predict future sentiment using Random Forest"""
+    try:
+        # Prepare features
+        ts_df = prepare_time_series_data(df)
+        if ts_df is None or len(ts_df) < 10:
+            return None
+            
+        X = ts_df[['days_since_start', 'day_of_week', 'day_of_month']]
+        y = ts_df['Average']
+        
+        # Train model
+        model = RandomForestRegressor(n_estimators=100, random_state=42)
+        model.fit(X, y)
+        
+        # Create future features
+        last_date = ts_df['date'].max()
+        future_dates = [last_date + timedelta(days=i) for i in range(1, periods+1)]
+        future_days_since = [(d - ts_df['date'].min()).days for d in future_dates]
+        
+        future_X = pd.DataFrame({
+            'days_since_start': future_days_since,
+            'day_of_week': [d.weekday() for d in future_dates],
+            'day_of_month': [d.day for d in future_dates]
+        })
+        
+        # Make predictions
+        predictions = model.predict(future_X)
+        
+        return pd.DataFrame({
+            'date': future_dates,
+            'predicted_sentiment': predictions,
+            'model': 'Random Forest'
+        })
+    except Exception as e:
+        st.error(f"Error with Random Forest prediction: {str(e)}")
+        return None
+
+def plot_sentiment_predictions(history_df, predictions):
+    """Plot historical data and predictions"""
+    try:
+        # Prepare historical data
+        history_df = history_df.set_index('date').resample('D')['Average'].mean().reset_index()
+        
+        # Create figure
+        fig = px.line(history_df, x='date', y='Average', 
+                     title='Historical Sentiment & Future Predictions',
+                     labels={'Average': 'Sentiment Score'})
+        
+        # Add prediction traces
+        for model_name, pred_df in predictions.items():
+            if pred_df is not None:
+                fig.add_scatter(x=pred_df['date'], y=pred_df['predicted_sentiment'],
+                               mode='lines', name=f'{model_name} Prediction',
+                               line=dict(dash='dot'))
+                
+                # Add confidence interval if available
+                if 'lower_bound' in pred_df.columns and 'upper_bound' in pred_df.columns:
+                    fig.add_trace(px.area(pred_df, x='date', 
+                                         y_upper='upper_bound', 
+                                         y_lower='lower_bound',
+                                         title='').data[0])
+        
+        fig.update_layout(hovermode="x unified", showlegend=True)
+        return fig
+    except Exception as e:
+        st.error(f"Error plotting predictions: {str(e)}")
+        return None
+
 # --------------------------
 # Data Fetching Functions
 # --------------------------
@@ -246,7 +394,7 @@ def plot_sentiment_distribution(df, keyword):
 # --------------------------
 
 def main():
-    st.title("🌟 SentimentSync: Live Sentiment Analysis Dashboard")
+    st.title("🌟 SentimentSync: Live Sentiment Analysis & Prediction Dashboard")
     
     # Sidebar controls
     with st.sidebar:
@@ -274,6 +422,7 @@ def main():
         st.markdown("---")
         st.markdown("### Settings")
         show_raw_data = st.checkbox("Show raw data", value=False)
+        enable_prediction = st.checkbox("Enable sentiment prediction", value=True)
         st.markdown("---")
         st.button("🔄 Reset Analysis")
     
@@ -374,7 +523,7 @@ def main():
                 st.subheader("📝 Word Cloud")
                 combined_text = " ".join(df['text'])
                 wordcloud_img = f'data:image/png;base64,{generate_wordcloud(combined_text)}'
-                st.image(wordcloud_img, use_column_width=True)
+                st.image(wordcloud_img, use_container_width=True)
                 
                 # Filter recent data (last 14 days)
                 df['date'] = pd.to_datetime(df['date'])
@@ -390,6 +539,41 @@ def main():
                     st.subheader("📊 Sentiment Distribution")
                     plot_sentiment_distribution(df_recent, keyword)
                     
+                    # Sentiment prediction
+                    if enable_prediction and len(df_recent) >= 7:  # Need at least 7 days of data
+                        st.subheader("🔮 Sentiment Prediction (Next 15 Days)")
+                        
+                        with st.spinner("Training prediction models..."):
+                            # Prepare time series data
+                            ts_df = prepare_time_series_data(df_recent)
+                            
+                            if ts_df is not None and len(ts_df) >= 7:
+                                # Get predictions from different models
+                                predictions = {
+                                    'Prophet': predict_sentiment_prophet(ts_df),
+                                    'ARIMA': predict_sentiment_arima(ts_df),
+                                    'Random Forest': predict_sentiment_rf(ts_df)
+                                }
+                                
+                                # Filter out None predictions
+                                valid_predictions = {k: v for k, v in predictions.items() if v is not None}
+                                
+                                if valid_predictions:
+                                    # Plot predictions
+                                    fig = plot_sentiment_predictions(df_recent, valid_predictions)
+                                    if fig:
+                                        st.plotly_chart(fig, use_container_width=True)
+                                        
+                                        # Show prediction details
+                                        st.subheader("📋 Prediction Details")
+                                        for model_name, pred_df in valid_predictions.items():
+                                            st.markdown(f"**{model_name} Prediction**")
+                                            st.dataframe(pred_df.set_index('date').style.format("{:.2f}"), use_container_width=True)
+                                else:
+                                    st.warning("Could not generate predictions with the available data.")
+                            else:
+                                st.warning("Not enough data points for reliable prediction. Need at least 7 days of data.")
+                    
                     # Raw data (if enabled)
                     if show_raw_data:
                         st.subheader("📋 Raw Data")