Daily Stock Price Dashboard

1. Revisit the all-weather portfolio you crafted. Create the maximum Sharpe portfolio's daily return dataframe and then merge it with Fama French's five return factors

# Install yahoo finance API package !pip install yfinance

!pip install PyPortfolioOpt

import yfinance as yf import pandas as pd import numpy as np import datetime as dt import matplotlib.pyplot as plt # Define a list of stock tickers for your portfolio # 10 companies: Apple, Microsoft, Google, Amazon, NVIDIA, Tesla, Meta, UnitedHealth, Walmart, JPMorgan Chase stock_tickers = ["AAPL", "AMZN", "DIS", "GOOG", "IBM", "KO", "NFLX", "TM", "TSLA", "WMT"] # start and end dates for past 5-year start_date = dt.datetime(2018,9,8) end_date = dt.datetime(2023,9,8) # Download historical stock price data from Yahoo Finance stocks_price = yf.download(stock_tickers, start=start_date, end=end_date) # Extract adjusted closing prices adj_prices = stocks_price["Adj Close"] # Calculate the daily returns for each stock [.dropna()removes missing values)] daily_returns = adj_prices.pct_change().dropna() # print(daily_returns)

import pandas as pd import numpy as np from pypfopt.efficient_frontier import EfficientFrontier from pypfopt import risk_models from pypfopt import expected_returns # Load your asset price data into the 'adj_prices' DataFrame and define 'stock_tickers' # ... # Calculate expected annualized returns and sample covariance/risk mu = expected_returns.mean_historical_return(adj_prices) Sigma = risk_models.sample_cov(adj_prices) # Create an Efficient Frontier with the expected returns and covariance matrix ef_Max = EfficientFrontier(mu, Sigma) # Calculate the Maximum Sharpe Ratio portfolio raw_weights_MaxSharpe = ef_Max.max_sharpe() cleaned_weights_MaxSharpe = ef_Max.clean_weights() portfolio_returns_MaxSharpe = ef_Max.portfolio_performance(verbose=True) # Define a function to calculate portfolio characteristics def calculate_portfolio_characteristics(daily_returns, weights): # 1. Annualized portfolio return and volatility portReturn = np.sum(daily_returns.mean() * weights) annualized_portReturn = portReturn * 252 print(f"Portfolio's Annualized Return: {annualized_portReturn:.2%}") cov_matrix = (daily_returns.cov()) * 252 port_variance = np.dot(weights.T, np.dot(cov_matrix, weights)) port_stddev = np.sqrt(port_variance) print(f"Portfolio's Annualized Volatility/Std. Dev: {port_stddev:.3f}") # 3. Portfolio's daily return profile port_daily_return = daily_returns.dot(weights) # 4. Portfolio's cumulative return port_cumulative_return = (1 + port_daily_return).cumprod() return port_daily_return, port_cumulative_return # Extract weights of the Maximum Sharpe Ratio portfolio def extract_weights_as_array(ef_weight, stock_tickers): array_weight = np.array([ef_weight[ticker] for ticker in stock_tickers]) return array_weight # Calculate weights and characteristics for the Maximum Sharpe Ratio portfolio stock_tickers = adj_prices.columns array_weight_MaxSharpe = extract_weights_as_array(cleaned_weights_MaxSharpe, stock_tickers) print("MaxSharpe Portfolio's Weight: ", array_weight_MaxSharpe) # Calculate portfolio characteristics for the Maximum Sharpe Ratio portfolio portf_daily_return_MaxSharpe, portf_cumul_return_MaxSharpe = calculate_portfolio_characteristics(daily_returns, array_weight_MaxSharpe) # Create a DataFrame to store the Maximum Sharpe Ratio portfolio's daily returns MaxSharpe_portfolio = pd.DataFrame(index=daily_returns.index) MaxSharpe_portfolio["MaxSharpe dailyReturns"] = portf_daily_return_MaxSharpe # You can now merge this DataFrame with other data as needed. # ... # Print the Maximum Sharpe Ratio portfolio's daily returns DataFrame print(MaxSharpe_portfolio)

import pandas as pd # Define the file path for Fama French's five return factors data file_path = "/work/F-F_Research_Data_5_Factors_2x3_daily.CSV" # Load Fama French's five return factors data, skipping the first 3 rows FF_5_Factors_data = pd.read_csv(file_path, skiprows=3) # Rename the name of the first column to 'Date' FF_5_Factors_data.rename(columns={'Unnamed: 0': 'Date'}, inplace=True) # Convert the 'Date' column to datetime and set it as the index FF_5_Factors_data['Date'] = pd.to_datetime(FF_5_Factors_data['Date'], format='%Y%m%d') FF_5_Factors_data.set_index('Date', inplace=True) # Merge the Maximum Sharpe portfolio's daily return DataFrame with Fama French's five return factors merged_data = pd.merge(MaxSharpe_portfolio, FF_5_Factors_data, left_index=True, right_index=True, how='inner') # Print the merged DataFrame print(merged_data)

2. Examine visually the correlation between portfolio and factor returns.

import seaborn as sns import matplotlib.pyplot as plt # Select the relevant columns from your merged data data = merged_data[['MaxSharpe dailyReturns', 'Mkt-RF', 'SMB', 'HML', 'RMW', 'CMA']] # Calculate the correlation matrix correlation = data.corr() # Create a heatmap plt.figure(figsize=(10, 6)) sns.heatmap(correlation, annot=True, cmap='coolwarm', fmt=".2f", linewidths=.5) plt.title('Correlation Heatmap of Portfolio and Factor Returns', size=16) plt.show()

3. Regress the portfolio return on each factor and assess the portfolio's sensitivity to each factor. For the curious, optional challenge, how do you test whether the intercept (i.e., alpha) is significantly different from the risk-free rate for a single-factor regression?

!pip install statsmodels

import statsmodels.api as sm from scipy import stats # Add this import # Define your dependent variable (portfolio return) and independent variables (factors) portfolio_return = merged_data['MaxSharpe dailyReturns'] factors = merged_data[['Mkt-RF', 'SMB', 'HML', 'RMW', 'CMA']] # Add a constant term (intercept) to the independent variables factors = sm.add_constant(factors) # Perform multiple linear regression for each factor model = sm.OLS(portfolio_return, factors).fit() # Print regression summary for each factor for i, factor in enumerate(factors.columns): if i == 0: print("Single-Factor Regression Results:") else: print("\nFactor:", factor) print(model.get_robustcov_results(cov_type='HAC', maxlags=i).summary()) # To test if the intercept (alpha) is significantly different from the risk-free rate (Mkt-RF), you can use a t-test alpha = model.params[0] alpha_std_err = model.bse[0] t_stat = alpha / alpha_std_err # Calculate p-value for the t-test p_value = 2 * (1 - stats.t.cdf(abs(t_stat), df=model.df_resid)) print("\nTesting whether the alpha is significantly different from the risk-free rate (Mkt-RF):") print(f"Alpha: {alpha:.4f}") print(f"Standard Error of Alpha: {alpha_std_err:.4f}") print(f"T-Stat: {t_stat:.4f}") print(f"P-Value: {p_value:.4f}") # Determine if alpha is significantly different from the risk-free rate (Mkt-RF) alpha_significance = "significant" if p_value < 0.05 else "not significant" print(f"Alpha is {alpha_significance} at the 5% significance level.")

4. Regress the portfolio return on all factors and assess the portfolio's sensitivity to factors. For the curious, optional challenge, how do you test whether the intercept (i.e., alpha) is significantly different from the risk-free rate for a multi-factor regression?

import statsmodels.api as sm from scipy import stats # Define your dependent variable (portfolio return) and independent variables (all factors) portfolio_return = merged_data['MaxSharpe dailyReturns'] factors = merged_data[['Mkt-RF', 'SMB', 'HML', 'RMW', 'CMA']] # Add a constant term (intercept) to the independent variables factors = sm.add_constant(factors) # Perform multiple linear regression model = sm.OLS(portfolio_return, factors).fit() # Print the regression summary print("Multi-Factor Regression Results:") print(model.summary()) # To test if the intercept (alpha) is significantly different from the risk-free rate (Mkt-RF), you can use a t-test alpha = model.params[0] alpha_std_err = model.bse[0] t_stat = alpha / alpha_std_err # Calculate p-value for the t-test p_value = 2 * (1 - stats.t.cdf(abs(t_stat), df=model.df_resid)) print("\nTesting whether the alpha is significantly different from the risk-free rate (Mkt-RF):") print(f"Alpha: {alpha:.4f}") print(f"Standard Error of Alpha: {alpha_std_err:.4f}") print(f"T-Stat: {t_stat:.4f}") print(f"P-Value: {p_value:.4f}") # Determine if alpha is significantly different from the risk-free rate (Mkt-RF) alpha_significance = "significant" if p_value < 0.05 else "not significant" print(f"Alpha is {alpha_significance} at the 5% significance level.")

5. Optional Bonus. Construct a multi-factor pricing model for assets based on Arbitrage Pricing Theory.The Arbitrage Pricing Theory (APT) is a theory of asset pricing that holds that an asset’s returns can be forecasted with the linear relationship between an asset’s expected returns and the macroeconomic (e.g., GDP, changes in inflation, yield curve changes, changes in interest rates, market sentiments, exchange rates) or firm-specific statistical factors that affect the asset’s risk. Hint: You can draw these variables straight into your Jupyter notebook via Refinitiv API.