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
# Import the packages
import yfinance as yf
import datetime as dt
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Install yahoo finance API package
!pip install yfinance --upgrade --no-cache-dir
## Install PyPortfolioOpt package
!pip install PyPortfolioOpt
# Import the packages
from pypfopt import risk_models
from pypfopt import expected_returns
from pypfopt.efficient_frontier import EfficientFrontier
#list my own portfolio of stocks
ticker_symbol = ['AAPL','AMZN','GOOG','META','SONY','TSLA']
# Download historical data for the past 5 years
start_date = '2018-09-05'
end_date= '2023-09-05'
data = yf.download(ticker_symbol, start=start_date, end=end_date)
# Calculate return using method pct_change
price=data['Adj Close']
daily_returns=price.pct_change()
# Take portfolio's weight and creates daily portfolio returns
def portfolio_return_series(daily_returns, weights):
'''
INPUTS
daily returns: dataframe of daily returns
weights: numpy array of the portfolio weight
OUTPUTS
portfolio_daily_returns: the daily portfolio return
'''
# Create daily portfolio returns
portfolio_daily_returns = daily_returns.dot(weights)
return portfolio_daily_returns
Calculate the Maximum Sharpe Portfolio
# Calculate expected returns
mu = expected_returns.mean_historical_return(price)
# Calculate the covariance matrix
sigma = risk_models.sample_cov(price)
# Calculate the efficient frontier
ef = EfficientFrontier(mu, sigma)
# Calculate weights for the maximum Sharpe ratio portfolio
raw_weights_maxsharpe = ef.max_sharpe()
cleaned_weights_maxsharpe = ef.clean_weights()
optimal_weights_maxsharpe = np.array(list(cleaned_weights_maxsharpe.values()))
print (optimal_weights_maxsharpe)
Calculate the Minimum Volatility Portfolio
# Calculate the efficient frontier
ef = EfficientFrontier(mu, sigma)
# Calculate weights for the minimum volatility portfolio
raw_weights_minvol = ef.min_volatility()
cleaned_weights_minvol = ef.clean_weights()
optimal_weights_minvol = np.array(list(cleaned_weights_minvol.values()))
print (optimal_weights_minvol)
# Equally-weighted portfolio's daily returns
weights = np.array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
portfolio_ew = portfolio_return_series(daily_returns, weights)
# The maximum Sharpe portfolio
# Extract the first element from the function output for daily returns
portfolio_maxsharpe = portfolio_return_series(daily_returns, optimal_weights_maxsharpe)
# The minimum volatility portfolio
# Extract the first element from the function output for daily returns
portfolio_minvol = portfolio_return_series(daily_returns, optimal_weights_minvol)
# Merge the series into a dataframe
portfolio_returns = pd.concat([portfolio_ew, portfolio_maxsharpe, portfolio_minvol], axis=1)
portfolio_returns.columns = ['ew_portfolio', 'maxsharpe_portfolio', 'minvol_portfolio']
# Dispay the portfolio_returns dataframe
portfolio_returns.tail()
# Read the csv file
factors = pd.read_csv("updated return.CSV", parse_dates=['Date'])
factors.set_index(factors['Date'], inplace=True)
factors.drop(columns=['Date'], inplace=True)
factors = factors.loc[:].div(100)
# Display the dataframe
factors.info()
factors.tail()
# Combine the daily portfolio return and cumulative returns
portfolio_factors = pd.merge(portfolio_returns, factors, how='inner', left_index=True, right_index=True)
# Display the returns
portfolio_factors.tail()
# Display the correlation
factors = ['Mkt-RF', 'SMB', 'HML', 'RMW', 'CMA']
portfolio_return = ['ew_portfolio', 'maxsharpe_portfolio', 'minvol_portfolio']
print(portfolio_factors[factors + portfolio_return].corr())
2. Examine visually the correlation between portfolio and factor returns.
# Take portfolio and factors returns and form a correlation
def correlation_of_portfolio(portfolio_type, df):
'''
INPUTS
portfolio type: ew_portfolio, maxsharpe_portfolio, minvol_portfolio
df: dataframe includes portfolio and factor returns
OUTPUTS
plot the correlation between a portfolio and factor returns
'''
for factor in factors:
# Calculate the correlation with the market
df['correlation_'+ factor]=df[portfolio_type].rolling(20).corr(df[factor])
# Plot the correlation between a portfolio and factor returns
df['correlation_'+ factor].plot()
plt.legend(loc='center left', bbox_to_anchor=(1, 1))
return
correlation_of_portfolio("ew_portfolio", portfolio_factors)
correlation_of_portfolio("maxsharpe_portfolio", portfolio_factors)
correlation_of_portfolio("minvol_portfolio", portfolio_factors)
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==0.14.0
# Import the package
import statsmodels.api as sm
# Compute the regression of the portfolio return on each factor
def sensitivity_of_portfolio_factor(type_of_portfolio, df):
'''
INPUTS
portfolio type: ew_portfolio, maxsharpe_portfolio, minvol_portfolio
df: dataframe includes portfolio and factor returns
OUTPUTS
regression of the portfolio
'''
for factor in factors:
# Create the model
y = df[type_of_portfolio]
X = df[factor]
X = sm.add_constant(X)
model = sm.OLS(y, X)
# Print the summary
model = model.fit()
print(model.summary())
return
sensitivity_of_portfolio_factor("ew_portfolio", portfolio_factors)
sensitivity_of_portfolio_factor("maxsharpe_portfolio", portfolio_factors)
sensitivity_of_portfolio_factor("minvol_portfolio", portfolio_factors)
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 the package
import statsmodels.api as sm
# Compute the regression of the portfolio returns for all factor
def sensitivity_of_all_factor_portfolio(type_of_portfolio, df):
'''
INPUTS
portfolio type: ew_portfolio, maxsharpe_portfolio, minvol_portfolio
df: dataframe includes portfolio and factor returns
OUTPUTS
regression of the portfolio
'''
# Create the model object
y = df[type_of_portfolio]
X = df[factors]
X = sm.add_constant(X)
model = sm.OLS(y, X)
# Print the summary
model = model.fit()
print(model.summary())
return
sensitivity_of_all_factor_portfolio('ew_portfolio', portfolio_factors)
sensitivity_of_all_factor_portfolio('maxsharpe_portfolio', portfolio_factors)
sensitivity_of_all_factor_portfolio('minvol_portfolio', portfolio_factors)