Create app.py

app.py

@@ -0,0 +1,590 @@
+import streamlit as st
+import yfinance as yf
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from statsmodels.tsa.api import VAR
+from statsmodels.tsa.stattools import adfuller
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.metrics import mean_squared_error, mean_absolute_error, mean_absolute_percentage_error, r2_score
+from datetime import datetime, timedelta
+
+# Helper functions remain unchanged
+def download_data(tickers, start_date, end_date):
+    data = {}
+    for name, ticker in tickers.items():
+        data[name] = yf.download(ticker, start=start_date, end=end_date)
+    return data
+
+def calculate_returns_and_volatility(data, rolling_window):
+    stock_data = data['stock']
+    stock_data['Log_Returns'] = np.log(stock_data['Adj Close'] / stock_data['Adj Close'].shift(1))
+    stock_data['Volatility'] = stock_data['Log_Returns'].rolling(window=rolling_window).std() * np.sqrt(252)
+    stock_data = stock_data.dropna()
+    data['stock'] = stock_data
+
+    sp500_data = data['sp500']
+    sp500_data['Log_Returns'] = np.log(sp500_data['Adj Close'] / sp500_data['Adj Close'].shift(1))
+    sp500_data['SP500_Volatility'] = sp500_data['Log_Returns'].rolling(window=rolling_window).std() * np.sqrt(252)
+    sp500_data = sp500_data.dropna()
+    data['sp500'] = sp500_data
+
+    return data
+
+def merge_data(data):
+    merged_data = data['stock'][['Volatility']].copy()
+    merged_data['SP500'] = data['sp500']['Adj Close']
+    merged_data['SP500_Volatility'] = data['sp500']['SP500_Volatility']
+    merged_data['VIX'] = np.log(data['vix']['Adj Close'])
+    merged_data['SP500_Returns'] = data['sp500']['Log_Returns']
+    merged_data['Volume'] = data['stock']['Volume']
+    merged_data['Stock_Returns'] = data['stock']['Log_Returns']
+    merged_data = merged_data.dropna()
+    return merged_data
+
+def check_stationarity_and_difference(df):
+    """
+    Perform ADF test for stationarity and apply differencing if necessary.
+    """
+    for column in df.columns:
+        result = adfuller(df[column].dropna())
+        p_value = result[1]
+        if p_value > 0.05:
+            # Non-stationary series; apply differencing
+            df[column] = df[column].diff()
+        else:
+            pass  # Series is stationary; no differencing needed
+
+def normalize_data(df):
+    scaler = MinMaxScaler(feature_range=(0, 1))
+    scaled_data = pd.DataFrame(scaler.fit_transform(df), columns=df.columns, index=df.index)
+    return scaled_data, scaler
+
+def fit_var_model(scaled_data, max_lags=30):
+    model = VAR(scaled_data)
+    lag_order_results = model.select_order(maxlags=max_lags)
+    optimal_lag = lag_order_results.aic
+    results = model.fit(optimal_lag)
+    return results, optimal_lag
+
+def forecast_future_values(results, scaled_data, scaler, steps, optimal_lag):
+    forecast_95, lower_95, upper_95 = results.forecast_interval(
+        scaled_data.values[-optimal_lag:], steps=steps, alpha=0.05)
+    forecast_68, lower_68, upper_68 = results.forecast_interval(
+        scaled_data.values[-optimal_lag:], steps=steps, alpha=0.32)
+    
+    forecast_original = scaler.inverse_transform(forecast_95)
+    lower_95_original = scaler.inverse_transform(lower_95)
+    upper_95_original = scaler.inverse_transform(upper_95)
+    lower_68_original = scaler.inverse_transform(lower_68)
+    upper_68_original = scaler.inverse_transform(upper_68)
+
+    return forecast_original, lower_95_original, upper_95_original, lower_68_original, upper_68_original
+
+# Plotting functions remain unchanged
+def plot_forecast(merged_data, future_dates, volatility_predictions, lower_volatility_95, upper_volatility_95, lower_volatility_68, upper_volatility_68):
+    fig = go.Figure()
+
+    # Plot historical volatility
+    fig.add_trace(go.Scatter(x=merged_data.index, y=merged_data['Volatility'], mode='lines', name='Historical Volatility'))
+
+    # Plot 95% confidence intervals
+    fig.add_trace(go.Scatter(x=future_dates, y=upper_volatility_95, fill=None, mode='lines', line_color='lightgray', name='95% CI Upper'))
+    fig.add_trace(go.Scatter(x=future_dates, y=lower_volatility_95, fill='tonexty', mode='lines', line_color='lightgray', name='95% CI Lower'))
+
+    # Plot 68% confidence intervals
+    fig.add_trace(go.Scatter(x=future_dates, y=upper_volatility_68, fill=None, mode='lines', line_color='blue', name='68% CI Upper'))
+    fig.add_trace(go.Scatter(x=future_dates, y=lower_volatility_68, fill='tonexty', mode='lines', line_color='blue', name='68% CI Lower'))
+    
+    # Plot predicted volatility
+    fig.add_trace(go.Scatter(x=future_dates, y=volatility_predictions, mode='lines',line_color='orange' ,name='Predicted Volatility', line=dict(dash='dot', width=4)))
+
+    fig.update_layout(title='VAR Predicted Volatility with Confidence Intervals',
+                      xaxis_title='Date', yaxis_title='Volatility',
+                      template='plotly_white')
+
+    return fig
+
+def plot_extended_forecast(forecast_data_extended, future_dates, volatility_predictions):
+    """
+    Plot extended actual historical volatility and predicted future volatility using Plotly.
+    """
+    # Align the length of future dates and predicted values
+    future_dates = future_dates[:len(volatility_predictions)]
+    volatility_predictions = volatility_predictions[:len(future_dates)]
+
+    fig = go.Figure()
+
+    # Plot extended actual historical volatility
+    fig.add_trace(go.Scatter(x=forecast_data_extended.index, y=forecast_data_extended['Volatility'], mode='lines', name='Extended Historical Volatility'))
+
+    # Plot predicted future volatility
+    fig.add_trace(go.Scatter(x=future_dates, y=volatility_predictions, mode='lines', name='Predicted Future Volatility', line=dict(dash='dash')))
+
+    fig.update_layout(title='Predicted Volatility with Extended Actual Data',
+                      xaxis_title='Date',
+                      yaxis_title='Volatility',
+                      template='plotly_white')
+
+    return fig
+
+def calculate_performance_metrics(forecast_data_extended, future_dates, volatility_predictions):
+    """
+    Calculate performance metrics and return as markdown text.
+    """
+    # Ensure future_dates are in the same format as the forecast_data index
+    new_future_dates = pd.to_datetime(future_dates)
+
+    # Create a DataFrame for future dates and predicted values
+    predicted_df = pd.DataFrame({
+        'Date': new_future_dates,
+        'Predicted Volatility': volatility_predictions
+    }).set_index('Date')
+
+    # Extract the actual future volatility values for the prediction period
+    actual_volatility = forecast_data_extended.loc[new_future_dates, 'Volatility']
+
+    # Create DataFrame for actual values
+    actual_df = pd.DataFrame({
+        'Date': actual_volatility.index,
+        'Actual Volatility': actual_volatility.values
+    }).set_index('Date')
+
+    # Join the actual and predicted DataFrames on the Date index
+    results_df = actual_df.join(predicted_df, how='inner')
+
+    # Metrics calculation
+    rmse = np.sqrt(mean_squared_error(results_df['Actual Volatility'], results_df['Predicted Volatility']))
+    mape = mean_absolute_percentage_error(results_df['Actual Volatility'], results_df['Predicted Volatility'])
+    mae = mean_absolute_error(results_df['Actual Volatility'], results_df['Predicted Volatility'])
+    mse = mean_squared_error(results_df['Actual Volatility'], results_df['Predicted Volatility'])
+    r2 = r2_score(results_df['Actual Volatility'], results_df['Predicted Volatility'])
+
+    metrics = f"""
+    **RMSE**: {rmse:.4f}  
+    **MAPE**: {mape:.2%}  
+    **MAE**: {mae:.4f}  
+    **MSE**: {mse:.4f}  
+    **R²**: {r2:.4f}
+    """
+
+    return metrics
+
+def plot_residuals_plotly(results):
+    """
+    Plot residuals of VAR model using Plotly.
+    """
+    residuals = results.resid
+    fig = go.Figure()
+    for col in residuals.columns:
+        fig.add_trace(go.Scatter(x=residuals.index, y=residuals[col], mode='lines', name=f'Residuals: {col}'))
+
+    fig.update_layout(title='Residuals of VAR Model',
+                      xaxis_title='Date', yaxis_title='Residuals',
+                      template='plotly_white')
+    return fig
+
+def calculate_metrics_and_plot_errors_plotly(forecast_data_extended, future_dates, volatility_predictions):
+    """
+    Calculate performance metrics and plot prediction errors using Plotly.
+    """
+    # Ensure future_dates are in the same format as the forecast_data index
+    new_future_dates = pd.to_datetime(future_dates)
+
+    # Create a DataFrame for future dates and predicted values
+    predicted_df = pd.DataFrame({
+        'Date': new_future_dates,
+        'Predicted Volatility': volatility_predictions
+    }).set_index('Date')
+
+    # Extract the actual future volatility values for the prediction period
+    actual_volatility = forecast_data_extended.loc[new_future_dates, 'Volatility']
+
+    # Create DataFrame for actual values
+    actual_df = pd.DataFrame({
+        'Date': actual_volatility.index,
+        'Actual Volatility': actual_volatility.values
+    }).set_index('Date')
+
+    # Join the actual and predicted DataFrames on the Date index
+    results_df = actual_df.join(predicted_df, how='inner')
+
+    # Calculate errors over time
+    results_df['Error'] = results_df['Actual Volatility'] - results_df['Predicted Volatility']
+
+    # Create a Plotly figure with two subplots
+    fig = make_subplots(rows=2, cols=1, subplot_titles=("Scatter Plot of Predicted vs Actual Volatility", "Prediction Error Over Time"))
+
+    # Scatter plot of predicted vs actual values
+    fig.add_trace(
+        go.Scatter(
+            x=results_df['Actual Volatility'],
+            y=results_df['Predicted Volatility'],
+            mode='markers',
+            name='Predicted vs Actual'
+        ),
+        row=1, col=1
+    )
+
+    # Add a line y = x
+    min_vol = min(results_df['Actual Volatility'].min(), results_df['Predicted Volatility'].min())
+    max_vol = max(results_df['Actual Volatility'].max(), results_df['Predicted Volatility'].max())
+    fig.add_trace(
+        go.Scatter(
+            x=[min_vol, max_vol],
+            y=[min_vol, max_vol],
+            mode='lines',
+            name='Perfect Prediction',
+            line=dict(dash='dash', color='red')
+        ),
+        row=1, col=1
+    )
+
+    # Error plot over time
+    fig.add_trace(
+        go.Scatter(
+            x=results_df.index,
+            y=results_df['Error'],
+            mode='lines+markers',
+            name='Prediction Error'
+        ),
+        row=2, col=1
+    )
+
+    fig.update_layout(height=700, title="Model Performance: Prediction Errors", template='plotly_white')
+    fig.update_xaxes(title_text='Actual Volatility', row=1, col=1)
+    fig.update_yaxes(title_text='Predicted Volatility', row=1, col=1)
+    fig.update_xaxes(title_text='Date', row=2, col=1)
+    fig.update_yaxes(title_text='Error (Actual - Predicted)', row=2, col=1)
+
+    return fig
+
+def extended_forecast_evaluation(tickers, rolling_window, forecast_start_date,
+                                 forecast_end_date, future_dates, volatility_predictions):
+    """
+    Extend forecast evaluation by comparing with actual data over an extended period.
+    """
+    # Derive extended_start_date to ensure we have enough data for the rolling window
+    extended_start_date = (forecast_start_date - timedelta(days=rolling_window * 3)).strftime('%Y-%m-%d')
+
+    # Extended end date includes extra days for comparison
+    extended_end_date = forecast_end_date + timedelta(days=extra_days)
+
+    # Download the extended actual data for the stock
+    extended_actual_data = yf.download(tickers['stock'], start=extended_start_date, end=extended_end_date.strftime('%Y-%m-%d'))
+
+    # Calculate daily returns and rolling volatility for the extended data
+    extended_actual_data['Returns'] = extended_actual_data['Adj Close'].pct_change()
+    extended_actual_data['Volatility'] = extended_actual_data['Returns'].rolling(window=rolling_window).std() * np.sqrt(252)
+
+    # Create forecast horizon DataFrame
+    forecast_horizon = pd.DataFrame(index=future_dates)
+    forecast_horizon['Volatility'] = np.nan
+
+    # Combine extended actual data with forecast horizon
+    forecast_data_extended = pd.concat([extended_actual_data, forecast_horizon], axis=0).sort_index()
+    forecast_data_extended['Volatility'] = forecast_data_extended['Volatility'].fillna(method='ffill')
+    forecast_data_extended = forecast_data_extended.dropna(subset=['Volatility'])
+
+    return forecast_data_extended
+
+# Set page configuration for a wide layout
+st.set_page_config(layout="wide")
+
+st.title("Stock Volatility Prediction")
+
+st.sidebar.title("Input Parameters")
+
+# How-to-use instructions in an expander
+with st.sidebar.expander("How to Use the App", expanded=False):
+    st.markdown("""
+    **Step 1**: Select the page you want to use (Real-time Predictions or Model Performance).  
+    **Step 2**: Enter the stock ticker symbol you wish to analyze.  
+    **Step 3**: Adjust the start and end dates for your analysis.  
+    **Step 4**: Configure additional parameters like rolling window and forecast horizon.  
+    **Step 5**: Click the **Run Model** button to generate the forecasts and view the results.
+    """)
+    
+# Pages
+page = st.sidebar.radio("Choose Page", ("Real-time Predictions", "Model Performance"))
+
+# Common Sidebar inputs within an expander (opened by default)
+with st.sidebar.expander("Ticker and Date Selection", expanded=True):
+    stock_ticker = st.text_input("Stock Ticker", value="ASML", help="Enter the ticker symbol of the stock you want to analyze (e.g., AAPL for Apple Inc.).")
+
+# Hide VIX and SP500 tickers by using default values internally
+tickers = {"stock": stock_ticker, "sp500": "^GSPC", "vix": "^VIX"}
+
+# Additional parameters within another expander (opened by default)
+with st.sidebar.expander("Model Parameters", expanded=True):
+    rolling_window = st.number_input(
+        "Rolling Window",
+        min_value=1,
+        value=21,
+        help="The number of days to use for calculating the rolling volatility."
+    )
+    n_days = st.number_input(
+        "Forecast Horizon (Days)",
+        min_value=1,
+        value=30,
+        help="The number of future days over which to forecast volatility."
+    )
+    if page == "Model Performance":
+        extra_days = st.number_input(
+            "Extra Days of Actual Data for Comparison",
+            min_value=1,
+            value=15,
+            help="Additional days of actual future data to include for comparison with the forecast."
+        )
+
+# Separate Start and End Dates for each page within the expander
+if page == "Real-time Predictions":
+    with st.sidebar.expander("Date Range Selection", expanded=True):
+        start_date_rt = st.date_input(
+            "Start Date",
+            value=datetime(2020, 1, 1),
+            key='start_date_rt',
+            help="The start date for getting the historical data."
+        )
+        end_date_rt = st.date_input(
+            "End Date",
+            value=datetime.now(),
+            key='end_date_rt',
+            max_value=datetime.now(),
+            help="The end date for getting the historical data."
+        )
+
+    # Context description in the main body
+    st.markdown("""
+    ### Real-time Predictions
+    This apps allows you to generate real-time forecasts of stock price volatility using an advanced multi-variate deep learning learning model using external factors. Volatility is calculated as the rolling standard deviation of the stock's daily log returns. The model provides confidence intervals (68% and 95%) to represent uncertainty in the predictions.
+    """)
+
+
+    # Run button
+    run_button = st.sidebar.button("Run Model", key='run_button_rt')
+
+    # Placeholder for plots
+    plot_placeholder = st.empty()
+
+    if run_button:
+        with st.spinner("Downloading data and processing..."):
+            data = download_data(tickers, start_date_rt, end_date_rt)
+            data = calculate_returns_and_volatility(data, rolling_window)
+            merged_data = merge_data(data)
+
+            # Preprocess the data
+            scaled_data, scaler = normalize_data(merged_data)
+
+            # Fit the VAR model
+            results, optimal_lag = fit_var_model(scaled_data)
+
+            # Forecast future values
+            forecast_original, lower_95_original, upper_95_original, lower_68_original, upper_68_original = forecast_future_values(
+                results, scaled_data, scaler, n_days, optimal_lag)
+
+            volatility_predictions = forecast_original[:, 0]
+            lower_volatility_95 = lower_95_original[:, 0]
+            upper_volatility_95 = upper_95_original[:, 0]
+            lower_volatility_68 = lower_68_original[:, 0]
+            upper_volatility_68 = upper_68_original[:, 0]
+
+            future_dates = pd.date_range(start=end_date_rt + timedelta(days=1), periods=n_days, freq='B')
+
+            # Display the forecast plot
+            forecast_fig = plot_forecast(merged_data, future_dates, volatility_predictions,
+                                         lower_volatility_95, upper_volatility_95,
+                                         lower_volatility_68, upper_volatility_68)
+
+            # Store results in session_state
+            st.session_state['rt_results'] = {'forecast_fig': forecast_fig}
+
+        # Display the plot using the placeholder
+        with plot_placeholder:
+            st.subheader("Forecasted Volatility")
+            st.plotly_chart(forecast_fig)
+    elif 'rt_results' in st.session_state:
+        # Display stored plot using the placeholder
+        with plot_placeholder:
+            st.subheader("Forecasted Volatility")
+            st.plotly_chart(st.session_state['rt_results']['forecast_fig'])
+
+elif page == "Model Performance":
+    with st.sidebar.expander("Date Range Selection", expanded=True):
+        # Model Performance page date inputs
+        start_date_mp = st.date_input(
+            "Start Date",
+            value=datetime(2020, 1, 1),
+            key='start_date_mp',
+            help="The start date for downloading historical data."
+        )
+        # Calculate the maximum allowable end date for model performance
+        today = datetime.now().date()
+        max_end_date_mp = today - timedelta(days=int(n_days + extra_days))
+        end_date_mp = st.date_input(
+            "End Date",
+            value=max_end_date_mp,
+            max_value=max_end_date_mp,
+            key='end_date_mp',
+            help="The end date for training the model. Cannot exceed the maximum allowed date."
+        )
+
+    # Context description in the main body
+    st.markdown("""
+    ### Model Performance
+    Here you assess how well the model forecasts volatility by comparing predicted values with actual historical (unseen) data. djust the parameters in the sidebar and click **Run Model** to assess performance.
+    """)
+    
+    with st.expander("The following analyses are performed", expanded=False):
+        st.markdown("""
+        1. **Predicted vs Actual Volatility**: The app compares the predicted stock volatility with actual volatility over a given time period. Volatility is calculated as the rolling standard deviation of daily log returns. The forecasted values are plotted alongside actual values to visualize performance.
+
+        2. **Residual Analysis**: Residuals represent the difference between the actual and predicted values. A plot of the residuals helps identify patterns or systematic errors in the predictions, such as under or overestimation.
+
+        3. **Error Metrics**: The app calculates several error metrics to quantify the accuracy of the predictions:
+            - **RMSE (Root Mean Squared Error)**: Measures the average magnitude of errors in the predictions, penalizing larger errors.
+            - **MAE (Mean Absolute Error)**: Represents the average absolute difference between predicted and actual volatility.
+            - **MAPE (Mean Absolute Percentage Error)**: Shows the prediction accuracy as a percentage, providing a relative measure of performance.
+            - **R² (R-squared)**: Indicates how well the predicted values explain the variability in the actual volatility, with a value closer to 1 indicating better performance.
+
+        4. **Confidence Intervals**: The model provides 68% and 95% confidence intervals to quantify uncertainty around the predictions. Wider intervals indicate more uncertainty, while narrower ones suggest more confidence in the forecasts.
+
+        **Instructions:**
+        - **Adjust Parameters**: Set the rolling window, forecast horizon, and extra days for comparison in the sidebar.
+        - **Run the Model**: Click **Run Model** to download data, train the model, and evaluate its performance using actual market data.
+        - **Evaluate Results**: The app visualizes the results with performance metrics, residual plots, and error analysis to help gauge how well the model performs.
+        """)
+
+    # Run button
+    run_button = st.sidebar.button("Run Model", key='run_button_mp')
+
+    # Placeholders for plots and metrics
+    forecast_placeholder = st.empty()
+    extended_forecast_placeholder = st.empty()
+    metrics_placeholder = st.empty()
+    residual_placeholder = st.empty()
+    error_placeholder = st.empty()
+
+    if run_button:
+        with st.spinner("Downloading data and processing..."):
+            # Convert end_date_mp to datetime if necessary
+            adjusted_end_date = pd.to_datetime(end_date_mp)
+
+            # Extended end date includes n_days forecast plus extra_days for comparison
+            extended_end_date = adjusted_end_date + timedelta(days=n_days + extra_days)
+
+            data = download_data(tickers, start_date_mp, extended_end_date)
+            data = calculate_returns_and_volatility(data, rolling_window)
+            merged_data = merge_data(data)
+
+            # Ensure that the data is up to adjusted_end_date for training
+            merged_data_train = merged_data[merged_data.index <= adjusted_end_date]
+
+            # Check stationarity and difference if necessary
+            merged_data_diff = merged_data_train.copy()
+            check_stationarity_and_difference(merged_data_diff)
+            merged_data_diff = merged_data_diff.dropna()
+
+            # Normalize data
+            scaled_data, scaler = normalize_data(merged_data_diff)
+
+            # Fit VAR model
+            results, optimal_lag = fit_var_model(scaled_data)
+
+            # Forecast future values
+            forecast_original, lower_95_original, upper_95_original, lower_68_original, upper_68_original = forecast_future_values(
+                results, scaled_data, scaler, n_days, optimal_lag)
+
+            volatility_predictions = forecast_original[:, 0]
+            lower_volatility_95 = lower_95_original[:, 0]
+            upper_volatility_95 = upper_95_original[:, 0]
+            lower_volatility_68 = lower_68_original[:, 0]
+            upper_volatility_68 = upper_68_original[:, 0]
+
+            # Generate future dates
+            future_dates = pd.date_range(start=adjusted_end_date + timedelta(days=1), periods=n_days, freq='B')
+
+            # Extended forecast evaluation
+            forecast_start_date = future_dates[0]
+            forecast_end_date = future_dates[-1]
+            forecast_data_extended = extended_forecast_evaluation(
+                tickers, rolling_window, forecast_start_date,
+                forecast_end_date, future_dates, volatility_predictions)
+
+            # Plot forecast with confidence intervals
+            forecast_fig = plot_forecast(merged_data_train, future_dates, volatility_predictions,
+                                         lower_volatility_95, upper_volatility_95,
+                                         lower_volatility_68, upper_volatility_68)
+
+            # Plot extended forecast comparison
+            extended_forecast_fig = plot_extended_forecast(forecast_data_extended, future_dates, volatility_predictions)
+
+            # Calculate and display performance metrics
+            performance_metrics = calculate_performance_metrics(forecast_data_extended, future_dates, volatility_predictions)
+
+            # Plot residuals using Plotly
+            residual_fig = plot_residuals_plotly(results)
+
+            # Calculate metrics and plot errors using Plotly
+            error_fig = calculate_metrics_and_plot_errors_plotly(forecast_data_extended, future_dates, volatility_predictions)
+
+            # Store results in session_state
+            st.session_state['mp_results'] = {
+                'forecast_fig': forecast_fig,
+                'extended_forecast_fig': extended_forecast_fig,
+                'performance_metrics': performance_metrics,
+                'residual_fig': residual_fig,
+                'error_fig': error_fig
+            }
+
+        # Display plots and metrics using placeholders
+        with forecast_placeholder:
+            st.subheader("Forecast with Confidence Intervals")
+            st.plotly_chart(forecast_fig)
+
+        with extended_forecast_placeholder:
+            st.subheader("Extended Forecast Evaluation")
+            st.plotly_chart(extended_forecast_fig)
+
+        with metrics_placeholder:
+            st.markdown("#### Performance Metrics")
+            st.markdown(performance_metrics)
+
+        with residual_placeholder:
+            st.subheader("Residuals of Model")
+            st.plotly_chart(residual_fig)
+
+        with error_placeholder:
+            st.subheader("Prediction Errors")
+            st.plotly_chart(error_fig)
+
+    elif 'mp_results' in st.session_state:
+        # Display stored results using placeholders
+        with forecast_placeholder:
+            st.subheader("Forecast with Confidence Intervals")
+            st.plotly_chart(st.session_state['mp_results']['forecast_fig'])
+
+        with extended_forecast_placeholder:
+            st.subheader("Extended Forecast Evaluation")
+            st.plotly_chart(st.session_state['mp_results']['extended_forecast_fig'])
+
+        with metrics_placeholder:
+            st.markdown("#### Performance Metrics")
+            st.markdown(st.session_state['mp_results']['performance_metrics'])
+
+        with residual_placeholder:
+            st.subheader("Residuals of Model")
+            st.plotly_chart(st.session_state['mp_results']['residual_fig'])
+
+        with error_placeholder:
+            st.subheader("Prediction Errors")
+            st.plotly_chart(st.session_state['mp_results']['error_fig'])
+
+hide_streamlit_style = """
+<style>
+#MainMenu {visibility: hidden;}
+footer {visibility: hidden;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)