Decoding Economic Trends with Prophet: A Deep Dive into Financial Forecasting

import yfinance as yf
import pandas as pd
from pandas_datareader.data import DataReader
import plotly.express as px
import plotly.graph_objects as go
import logging
from datetime import datetime

# Set up basic logging to capture information on the process
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Fetch and prepare data
def fetch_and_prepare_data(ticker, start_date, end_date, frequency='MS'):
    """Fetch financial data based on ticker and prepare it for plotting."""
    try:
        data = yf.download(ticker, start=start_date, end=end_date, progress=False)
        data = data['Close'].resample(frequency).last()
        if data.empty:
            raise ValueError(f"Fetched empty DataFrame for ticker: {ticker}")
        data = data.reset_index()
        data.columns = ['Date', 'Value']
        logging.info(f"Data successfully fetched for {ticker}")
        return data
    except Exception as e:
        logging.error(f"Error fetching data for {ticker}: {e}")
        return pd.DataFrame(columns=['Date', 'Value'])

# Plot actual values using Plotly
def plot_actual_values_plotly(data, title, y_axis_info, y_axis_desc, metric_desc, save_to_file=False):
    """Plot the actual values of the data using Plotly."""
    fig = px.line(data, x='Date', y='Value', title=title, labels={'Date': 'Date', 'Value': y_axis_info})
    
    fig.update_traces(mode='lines', line=dict(width=2, color='blue'))
    
    # Add hover text for better understanding
    hover_text = [f"{date}: {value:.2f} ({y_axis_desc})" for date, value in zip(data['Date'], data['Value'])]
    fig.update_traces(hoverinfo='text', hovertext=hover_text)
    
    fig.update_layout(
        hovermode='x unified',
        template='plotly_white',
        title={
            'text': title,
            'y': 0.95,
            'x': 0.5,
            'xanchor': 'center',
            'yanchor': 'top'
        },
        xaxis_title='Date',
        yaxis_title=y_axis_info,
        font=dict(size=14, color='black'),
        margin=dict(l=80, r=60, t=100, b=120),
        annotations=[
            go.layout.Annotation(
                text=metric_desc,
                xref="paper", yref="paper",
                x=0.5, y=-0.15,
                showarrow=False,
                font=dict(size=12, color='black'),
                align='center'
            )
        ]
    )
    
    fig.show()
    
    if save_to_file:
        try:
            import kaleido
        except ImportError:
            logging.error("Kaleido is required for saving images. Please install it using 'pip install kaleido'")
            return
        filename = f"{title.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
        fig.write_image(filename)
        logging.info(f"Plot saved to {filename}")

# Main function to fetch data and plot
def main():
    start_date = "2010-01-01"
    end_date = pd.Timestamp.today().strftime('%Y-%m-%d')

    tickers_info = {
        "AAPL": {
            "title": "Apple Inc. (AAPL) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Apple Inc.",
            "metric_desc": "This chart tracks the closing stock price of Apple Inc. (AAPL)."
        },
        "MSFT": {
            "title": "Microsoft Corporation (MSFT) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Microsoft Corporation",
            "metric_desc": "This chart tracks the closing stock price of Microsoft Corporation (MSFT)."
        },
        "AMZN": {
            "title": "Amazon.com Inc. (AMZN) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Amazon.com Inc.",
            "metric_desc": "This chart tracks the closing stock price of Amazon.com Inc. (AMZN)."
        },
        "GOOGL": {
            "title": "Alphabet Inc. (GOOGL) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Alphabet Inc.",
            "metric_desc": "This chart tracks the closing stock price of Alphabet Inc. (GOOGL)."
        },
        "TSLA": {
            "title": "Tesla Inc. (TSLA) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Tesla Inc.",
            "metric_desc": "This chart tracks the closing stock price of Tesla Inc. (TSLA)."
        },
        "GOGO": {
            "title": "Gogo Inc. (GOGO) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Gogo Inc.",
            "metric_desc": "This chart tracks the closing stock price of Gogo Inc. (GOGO)."
        },
        "APRN": {
            "title": "Blue Apron Holdings Inc. (APRN) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Blue Apron Holdings Inc.",
            "metric_desc": "This chart tracks the closing stock price of Blue Apron Holdings Inc. (APRN)."
        },
        "HAIN": {
            "title": "Hain Celestial Group Inc. (HAIN) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Hain Celestial Group Inc.",
            "metric_desc": "This chart tracks the closing stock price of Hain Celestial Group Inc. (HAIN)."
        },
        "ETSY": {
            "title": "Etsy Inc. (ETSY) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Etsy Inc.",
            "metric_desc": "This chart tracks the closing stock price of Etsy Inc. (ETSY)."
        },
        "RIOT": {
            "title": "Riot Platforms Inc. (RIOT) Actual Values",
            "y_axis_info": "Stock Price (in USD)",
            "y_axis_desc": "Closing stock price of Riot Platforms Inc.",
            "metric_desc": "This chart tracks the closing stock price of Riot Platforms Inc. (RIOT)."
        }
    }

    for ticker, info in tickers_info.items():
        data = fetch_and_prepare_data(ticker, start_date, end_date)
        if not data.empty:
            plot_actual_values_plotly(
                data, 
                info["title"], 
                info["y_axis_info"], 
                info["y_axis_desc"], 
                info["metric_desc"],
                save_to_file=True
            )

if __name__ == "__main__":
    main()

import yfinance as yf
import pandas as pd
from pandas_datareader.data import DataReader
from prophet import Prophet
from prophet.diagnostics import cross_validation, performance_metrics
from prophet.plot import add_changepoints_to_plot, plot_cross_validation_metric, plot_components_plotly
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import logging
from datetime import datetime
from joblib import Parallel, delayed
import multiprocessing
import kaleido as kld

# Set up basic logging to capture information on the process
logging.basicConfig(level=logging.INFO)

# Fetch and prepare data
def fetch_and_prepare_data(ticker, start_date, end_date, frequency='MS'):
    """Fetch financial data based on ticker and prepare it for Prophet modeling."""
    try:
        if ticker in ['CPIAUCSL', 'MEHOINUSA672N']:
            data = DataReader(ticker, 'fred', start_date, end_date).asfreq(frequency).interpolate()
        else:
            data = yf.download(ticker, start=start_date, end=end_date, progress=False)
            data = data['Close'].resample(frequency).last()
        if data.empty:
            raise ValueError("Fetched empty DataFrame.")
        data = data.reset_index()
        data.columns = ['ds', 'y']
        logging.info(f"Data successfully fetched for {ticker}")
        return data
    except Exception as e:
        logging.error(f"Error fetching data for {ticker}: {e}")
        return pd.DataFrame(columns=['ds', 'y'])

# Fit Prophet model
def fit_prophet_model(data, periods, frequency, changepoint_prior_scale):
    """Fit a Prophet model with specified parameters."""
    try:
        model = Prophet(
            daily_seasonality=False,
            weekly_seasonality=True,
            yearly_seasonality=True,
            seasonality_mode='multiplicative',
            changepoint_prior_scale=changepoint_prior_scale
        )
        model.add_country_holidays(country_name='US')
        model.fit(data)
        future = model.make_future_dataframe(periods=periods, freq=frequency)
        forecast = model.predict(future)
        df_cv = cross_validation(model, initial='3650 days', period='180 days', horizon='365 days')
        df_p = performance_metrics(df_cv)
        mae = df_p['mae'].mean()
        return model, forecast, mae
    except Exception as e:
        logging.error(f"Error during Prophet model fitting: {e}")
        return None, None, float('inf')

# Forecast using Prophet
def forecast_with_prophet(data, periods, frequency='MS', iterations=1):
    """Create and apply a Prophet model to forecast future values."""
    if data.empty or len(data) < 2:
        logging.error("Insufficient data to fit model.")
        return None, None
    try:
        best_model = None
        best_forecast = None
        best_mae = float('inf')
        
        def run_iteration():
            return fit_prophet_model(data, periods, frequency, changepoint_prior_scale=0.05)

        num_cores = multiprocessing.cpu_count()
        logging.info(f"Using {num_cores} cores for parallel processing.")
        
        if num_cores > 1:
            results = Parallel(n_jobs=num_cores)(delayed(run_iteration)() for _ in range(iterations))
            for model, forecast, mae in results:
                if mae < best_mae:
                    best_mae = mae
                    best_model = model
                    best_forecast = forecast
        else:
            for i in range(iterations):
                model, forecast, mae = run_iteration()
                if mae < best_mae:
                    best_mae = mae
                    best_model = model
                    best_forecast = forecast
                logging.info(f"Iteration {i+1}: MAE = {mae}")
        
        logging.info("Forecast successfully created.")
        return best_forecast, best_model
    except Exception as e:
        logging.error(f"Error during forecasting with Prophet: {e}")
        return None, None

# Perform cross-validation
def perform_cross_validation(model, initial, period, horizon):
    """Perform cross-validation to evaluate the model."""
    if model is None:
        return None, None
    try:
        df_cv = cross_validation(model, initial=initial, period=period, horizon=horizon)
        df_p = performance_metrics(df_cv)
        plot_cross_validation_metric(df_cv, metric='mae')
        logging.info("Cross-validation completed successfully.")
        return df_cv, df_p
    except Exception as e:
        logging.error(f"Error during cross-validation: {e}")
        return None, None

# Plot forecasts
def plot_forecasts(data, forecast, model, title, save_to_file=False):
    """Generate interactive Plotly plots for better visualization."""
    if forecast is None:
        logging.error(f"Forecast for {title} is None, skipping plot.")
        return

    fig = go.Figure()

    # Historical data
    fig.add_trace(go.Scatter(x=data['ds'], y=data['y'], mode='lines', name='Historical', line=dict(color='blue')))

    # Forecast data
    fig.add_trace(go.Scatter(x=forecast['ds'], y=forecast['yhat'], mode='lines', name='Forecast', line=dict(color='red', dash='dash')))
    fig.add_trace(go.Scatter(x=forecast['ds'], y=forecast['yhat_lower'], fill=None, mode='lines', line=dict(color='gray'), showlegend=False))
    fig.add_trace(go.Scatter(x=forecast['ds'], y=forecast['yhat_upper'], fill='tonexty', mode='lines', line=dict(color='gray'), showlegend=False))

    # Annotations
    peak = forecast.loc[forecast['yhat'] == forecast['yhat'].max()]
    if not peak.empty:
        fig.add_annotation(x=peak['ds'].values[0], y=peak['yhat'].values[0], text=f"Peak: {peak['yhat'].values[0]:.2f}", showarrow=True, arrowhead=2)

    fig.update_layout(title=title, xaxis_title='Date', yaxis_title='Value', template='plotly_white')
    fig.show()

    if save_to_file:
        try:
            kld
        except ImportError:
            logging.error("Kaleido is required for saving images. Please install it using 'pip install kaleido'")
            return
        filename = f"{title.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
        fig.write_image(filename)
        logging.info(f"Plot saved to {filename}")

# Plot decomposition
def plot_decomposition(model, forecast, title, save_to_file=False):
    """Generate decomposition plots using Plotly."""
    if model is None or forecast is None:
        logging.error(f"Cannot plot decomposition for {title}, model or forecast is None.")
        return
    fig = plot_components_plotly(model, forecast)
    fig.update_layout(title=f"{title} - Decomposition")
    fig.show()

    if save_to_file:
        try:
            import kaleido
        except ImportError:
            logging.error("Kaleido is required for saving images. Please install it using 'pip install kaleido'")
            return
        filename = f"{title.replace(' ', '_').lower()}_decomposition_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
        fig.write_image(filename)
        logging.info(f"Decomposition plot saved to {filename}")

def main(save_to_file=False):
    start_date = "1990-01-01"
    end_date = pd.Timestamp.today().strftime('%Y-%m-%d')
    forecast_periods = 180  # Forecasting for 15 years with monthly data
    iterations = 1  # Number of iterations can be changed here

    # Data fetching and model preparation
    housing_data = fetch_and_prepare_data("ITB", start_date, end_date)
    print("Housing Data:", housing_data.head())
    if housing_data.empty:
        logging.error("Housing data is empty after fetching.")
    else:
        logging.info("Housing data fetched successfully.")

    cpi_data = fetch_and_prepare_data('CPIAUCSL', start_date, end_date)
    print("CPI Data:", cpi_data.head())
    income_data = fetch_and_prepare_data('MEHOINUSA672N', start_date, end_date)
    print("Income Data:", income_data.head())

    # Model application and forecasting
    housing_forecast, housing_model = forecast_with_prophet(housing_data, forecast_periods, iterations=iterations)
    print("Housing Forecast:", housing_forecast.head() if housing_forecast is not None else "None")
    if housing_forecast is None:
        logging.error("Housing forecast is None after model fitting.")
    else:
        logging.info("Housing forecast created successfully.")

    cpi_forecast, cpi_model = forecast_with_prophet(cpi_data, forecast_periods, iterations=iterations)
    income_forecast, income_model = forecast_with_prophet(income_data, forecast_periods, iterations=iterations)

    # Validation and performance evaluation
    if housing_model is not None:
        perform_cross_validation(housing_model, '3650 days', '180 days', '365 days')

    if cpi_model is not None:
        perform_cross_validation(cpi_model, '3650 days', '180 days', '365 days')

    if income_model is not None:
        perform_cross_validation(income_model, '3650 days', '180 days', '365 days')

    # Decomposition plots
    print("Displaying decomposition plots for all datasets...")
    plot_decomposition(housing_model, housing_forecast, 'Housing Market Forecast', save_to_file=True)
    plot_decomposition(cpi_model, cpi_forecast, 'CPI Forecast', save_to_file=True)
    plot_decomposition(income_model, income_forecast, 'Income Forecast', save_to_file=True)

    # Forecast plots
    print("Displaying forecast plots for all datasets...")
    plot_forecasts(housing_data, housing_forecast, housing_model, 'Housing Market Forecast', save_to_file=True)
    plot_forecasts(cpi_data, cpi_forecast, cpi_model, 'CPI Forecast', save_to_file=True)
    plot_forecasts(income_data, income_forecast, income_model, 'Income Forecast', save_to_file=True)

    # Combined plot
    print("Displaying combined plots for all datasets...")
    fig_combined = make_subplots(rows=3, cols=1, subplot_titles=['Housing Market Forecast', 'CPI Forecast', 'Income Forecast'])

    for i, (data, forecast, title) in enumerate(zip([housing_data, cpi_data, income_data],
                                                    [housing_forecast, cpi_forecast, income_forecast],
                                                    ['Housing Market Forecast', 'CPI Forecast', 'Income Forecast'])):
        if forecast is not None:
            fig_combined.add_trace(go.Scatter(x=data['ds'], y=data['y'], mode='lines', name=f'{title} - Historical', line=dict(color='blue')), row=i+1, col=1)
            fig_combined.add_trace(go.Scatter(x=forecast['ds'], y=forecast['yhat'], mode='lines', name=f'{title} - Forecast', line=dict(color='red', dash='dash')), row=i+1, col=1)
            fig_combined.add_trace(go.Scatter(x=forecast['ds'], y=forecast['yhat_lower'], fill=None, mode='lines', line=dict(color='gray'), showlegend=False), row=i+1, col=1)
            fig_combined.add_trace(go.Scatter(x=forecast['ds'], y=forecast['yhat_upper'], fill='tonexty', mode='lines', line=dict(color='gray'), showlegend=False), row=i+1, col=1)

    fig_combined.update_layout(height=900, title_text="Combined Forecasts")
    fig_combined.show()

    if save_to_file:
        try:
            import kaleido
        except ImportError:
            logging.error("Kaleido is required for saving images. Please install it using 'pip install kaleido'")
            return
        filename = f"combined_forecasts_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
        fig_combined.write_image(filename)
        logging.info(f"Combined plot saved to {filename}")

    # Summary of diagnostic statements
    print("\nSummary of Diagnostic Statements:")
    print("Housing Data:", housing_data.head())
    print("Housing Forecast:", housing_forecast.head() if housing_forecast is not None else "None")
    print("CPI Data:", cpi_data.head())
    print("Income Data:", income_data.head())

if __name__ == "__main__":
    main(save_to_file=True)