# Install yahoo finance module !pip install yfinance --upgrade --no-cache-dir

# Import necessary packages import yfinance as yf import datetime as dt import numpy as np import pandas as pd

# Pick a list of stocks to build an all-weather portfilio # Grab past 5 years data symbols_list = ["AAPL","AMZN","AAL","BA","BAC","DIS","KO","MSFT","TSLA"] start = dt.datetime(2018,8,31) end = dt.datetime(2023,8,31) data = yf.download(symbols_list, start=start,end=end)

# Explore dataframe data.info()

# Only keep the adjusted close in the dataframe price = data["Adj Close"] price.info()

price.pct_change()[1:].head()

daily_return = price.pct_change() # Print the daily return mean of each assets print("--Mean--") print(daily_return.mean()) # Print the daily return standard deviation of each assets print("--Standard Deviation--") print(daily_return.std()) # Print the daily return skewness of each assets print("--Skewness--") print(daily_return.skew())

from pandas import DataFrame mean_prices = price.mean() mean_daily_return = daily_return.mean() # Equal weight for portfolio len_columns = len(price.columns) weights = np.full(len_columns, 1/len_columns) # Calculate expeted portfolio performance port_daily_returns = DataFrame() port_daily_returns['All-weather portfolio'] = (weights*daily_return).sum(axis=1) # print(port_daily_returns) # Calculate annual expected portfolio performance cumulative_returns = (port_daily_returns['All-weather portfolio'][-1]+1).cumprod() port_ann_returns = ((1+cumulative_returns)**(1/5))-1 print('Annualized return ='+ str(port_ann_returns)) # Calculate covarience, varience, anad standard deviation cov_mat_port = daily_return.cov() var_port = np.dot(weights.T, np.dot(cov_mat_port,weights)) std_port = np.sqrt(var_port) # Calculate annual std std_ann_port = std_port*np.sqrt(252) print('Annualized standard deviation ='+str(std_ann_port)) # Assume 10-year US Treasury yield as risk free rate, which is 4.27% at 8 Sep 2023 risk_free = 0.0427 # Calculate sharpe ratio sharpe_ratio = (port_ann_returns-risk_free)/std_ann_port print('Sharpe ratio ='+ str(sharpe_ratio))

# Print the daily return mean print("Mean =" + str(port_daily_returns['All-weather portfolio'].mean())) # Print the daily return standard deviation print("Standard Deviation =" + str(port_daily_returns['All-weather portfolio'].std())) # Print the daily return skewness print("Skewness=" + str(port_daily_returns['All-weather portfolio'].skew())) # Print the daily return kurtosis print("Kurtosis=" + str(port_daily_returns['All-weather portfolio'].kurtosis()))

# Import packages import matplotlib.pyplot as plt # Calculate cumulative returns cumul_return_port = (port_daily_returns['All-weather protfolio']+1).cumprod() # Plot the cumulative returns plt.xlabel('Date') plt.ylabel('Cumulative Return') cumul_return_port.plot()

# Install package %pip install PyPortfolioOpt # Import packages from pypfopt import risk_models from pypfopt import expected_returns from pypfopt.efficient_frontier import EfficientFrontier

print("----- Maximum Sharpe portfolio -----") # Calculate expected returns and covarience matrix mu = expected_returns.mean_historical_return(price) sigma = risk_models.sample_cov(price) # Obtain the EfficientFrontier with mu and sigma ef = EfficientFrontier(mu, sigma) raw_weights = ef.max_sharpe() # Get interpretable weights cleaned_weights = ef.clean_weights() # Get performance numbers ef.portfolio_performance(verbose=True)

# Convert to list, then to array weights_array = np.array(list(cleaned_weights.values())) print(weights_array)

# Repeat steps of question 2, except equal weights mean_prices = price.mean() mean_daily_return = daily_return.mean() # Calculate expeted portfolio performance port_daily_returns['Sharpe Optimal'] = (weights_array*daily_return).sum(axis=1) # Calculate annual expected portfolio performance cumulative_returns_max = (port_daily_returns['Sharpe Optimal'][-1]+1).cumprod() port_ann_returns_max = ((1+cumulative_returns_max)**(1/5))-1 print('Annualized return ='+ str(port_ann_returns_max)) # Calculate covarience, varience, anad standard deviation cov_mat_port_max = daily_return.cov() var_port_max = np.dot(weights.T, np.dot(cov_mat_port_max,weights_array)) std_port_max = np.sqrt(var_port_max) # Calculate annual std std_ann_port_max = std_port_max*np.sqrt(252) print('Annualized standard deviation ='+str(std_ann_port_max)) # Assume 10-year US Treasury yield as risk free rate, which is 4.27% at 8 Sep 2023 risk_free = 0.0427 # Calculate sharpe ratio sharpe_ratio_max = (port_ann_returns_max-risk_free)/std_ann_port_max print('Sharpe ratio ='+ str(sharpe_ratio_max))

# Print the Maximum Sharpe daily return mean print("Mean =" + str(port_daily_returns['Sharpe Optimal'].mean())) # Print the Maximum Sharpe daily return standard deviation print("Standard Deviation =" + str(port_daily_returns['Sharpe Optimal'].std())) # Print the Maximum Sharpe daily return skewness print("Skewness=" + str(port_daily_returns['Sharpe Optimal'].skew())) # Print the Maximum Sharpe daily return kurtosis print("Kurtosis=" + str(port_daily_returns['Sharpe Optimal'].kurtosis()))

# Calculate cumulative returns maxs_cumul_return_port = (port_daily_returns['Sharpe Optimal']+1).cumprod() # Plot the cumulative returns plt.xlabel('Date') plt.ylabel('Cumulative Return') maxs_cumul_return_port.plot()

print("----- Minimum volatility portfolio -----") # Calculate expected returns and covarience matrix mu = expected_returns.mean_historical_return(price) sigma = risk_models.sample_cov(price) # Obtain the EfficientFrontier with mu and sigma ef = EfficientFrontier(mu, sigma) raw_weights_minv = ef.min_volatility() # Get interpretable weights cleaned_weights_minv = ef.clean_weights() # Get performance numbers ef.portfolio_performance(verbose=True)

# Convert to list, then to array weights_array_minv = np.array(list(cleaned_weights_minv.values())) print(weights_array_minv)

# Repeat steps of question 2, except equal weights mean_prices = price.mean() mean_daily_return = daily_return.mean() # Calculate expeted portfolio performance port_daily_returns['Volatility Optimal'] = (weights_array_minv*daily_return).sum(axis=1) # Calculate annual expected portfolio performance cumulative_returns_min = (port_daily_returns['Volatility Optimal'][-1]+1).cumprod() port_ann_returns_min = ((1+cumulative_returns_min)**(1/5))-1 print('Annualized return ='+ str(port_ann_returns_min)) # Calculate covarience, varience, anad standard deviation cov_mat_port_min = daily_return.cov() var_port_min = np.dot(weights.T, np.dot(cov_mat_port_min,weights_array_minv)) std_port_min = np.sqrt(var_port_min) # Calculate annual std std_ann_port_min = std_port_min*np.sqrt(252) print('Annualized standard deviation ='+str(std_ann_port_min)) # Assume 10-year US Treasury yield as risk free rate, which is 4.27% at 8 Sep 2023 risk_free = 0.0427 # Calculate sharpe ratio sharpe_ratio_min = (port_ann_returns_min-risk_free)/std_ann_port_min print('Sharpe ratio ='+ str(sharpe_ratio_min))

# Print the Minimum volatility daily return mean print("Mean =" + str(port_daily_returns['Volatility Optimal'].mean())) # Print the Minimum volatility daily return standard deviation print("Standard Deviation =" + str(port_daily_returns['Volatility Optimal'].std())) # Print the Minimum volatility daily return skewness print("Skewness=" + str(port_daily_returns['Volatility Optimal'].skew())) # Print the Minimum volatility daily return kurtosis print("Kurtosis=" + str(port_daily_returns['Volatility Optimal'].kurtosis()))

# Calculate cumulative returns minv_cumul_return_port = (port_daily_returns['Volatility Optimal']+1).cumprod() # Plot the cumulative returns plt.xlabel('Date') plt.ylabel('Cumulative Return') minv_cumul_return_port.plot()

def Performance_summary(return_df, digi): risk_free = 0.0427 mean = round(return_df.mean(),digi) std = round(return_df.std(),digi) skew = round(return_df.skew(),digi) kurt = round(return_df.kurtosis(),digi) cumulative_returns = (1+return_df).cumprod()[-1]-1 annual = (1 + cumulative_returns) ** (252 / len(return_df)) - 1 annualized_return = round(annual, digi) annualized_std = return_df.std()*np.sqrt(252) sharpe = round(((annualized_return-risk_free)/annualized_std), digi) array=pd.Series([ mean, std, skew, kurt, annualized_return, annualized_std, sharpe ]) index = ['Mean', 'Volatility', 'Skewness', 'Kurtosis', 'Annualized Return', 'Annualized Volatility', 'Sharpe Ratio'] return array

import matplotlib.pyplot as plt import pandas as pd def compare(return_df): i = 0 for column in return_df: cumulative_returns = (1 + return_df[column]).cumprod() - 1 plt.plot(cumulative_returns.index, cumulative_returns * 100, label=column) if i == 0: summary_df = pd.DataFrame(Performance_summary(return_df[column], 5)) else: performance = pd.DataFrame(Performance_summary(return_df[column], 5)) performance = performance.reset_index() # Reset the index for proper concatenation summary_df = pd.concat([summary_df, performance], axis=1) i += 1 plt.xlabel('Date') plt.ylabel('Cumulative Return') plt.legend() plt.show() print(summary_df)

# Maximize Sharpe Ratio ef = EfficientFrontier(mu, sigma) ef.add_objective(objective_functions.L2_reg, gamma=2) raw_weights_sharpe = ef.max_sharpe() # Get interpretable weights cleaned_weights_sharpe = ef.clean_weights() # Ensure the number of columns in historical_d_return matches the number of assets historical_d_return = historical_d_return.iloc[:, :len(cleaned_weights_sharpe)] # Calculate portfolio performance for Sharpe Optimal port_returns_sharpe = (historical_d_return * cleaned_weights_sharpe).sum(axis=1) # Minimum volatility ef = EfficientFrontier(mu, sigma) ef.add_objective(objective_functions.L2_reg, gamma=2) raw_weights_volatility = ef.min_volatility() # Get interpretable weights cleaned_weights_volatility = ef.clean_weights() # Ensure the number of columns in historical_d_return matches the number of assets historical_d_return = historical_d_return.iloc[:, :len(cleaned_weights_volatility)] # Calculate portfolio performance for Volatility Optimal port_returns_volatility = (historical_d_return * cleaned_weights_volatility).sum(axis=1)

# Import packages from pypfopt import black_litterman, EfficientFrontier, objective_functions, risk_models, expected_returns import numpy as np import pandas as pd import matplotlib.pyplot as plt from pypfopt.black_litterman import BlackLittermanModel # Define your mu and historical_d_return here # Make sure they have the same number of assets # Maximize Sharpe Ratio ef_sharpe = EfficientFrontier(mu, historical_d_return) ef_sharpe.add_objective(objective_functions.L2_reg, gamma=2) raw_weights_sharpe = ef_sharpe.max_sharpe() # Get interpretable weights cleaned_weights_sharpe = ef_sharpe.clean_weights() # Calculate portfolio performance for Sharpe Optimal port_returns_sharpe = (historical_d_return * cleaned_weights_sharpe).sum(axis=1) # Minimum volatility ef_volatility = EfficientFrontier(mu, historical_d_return) ef_volatility.add_objective(objective_functions.L2_reg, gamma=2) raw_weights_volatility = ef_volatility.min_volatility() # Get interpretable weights cleaned_weights_volatility = ef_volatility.clean_weights() # Calculate portfolio performance for Volatility Optimal port_returns_volatility = (historical_d_return * cleaned_weights_volatility).sum(axis=1) # Calculate Black-Litterman adjusted covariance matrix bl_model = BlackLittermanModel(mu, cov_matrix) bl_cov_matrix = bl_model.bl_cov_matrix() # Create Efficient Frontier using adjusted covariance matrix ef_bl = EfficientFrontier(expected_returns=mu, cov_matrix=bl_cov_matrix, weight_bounds=(0, 1)) ef_bl.add_objective(objective_functions.L2_reg, gamma=2) raw_weights_bl = ef_bl.max_sharpe() # Get interpretable weights cleaned_weights_bl = ef_bl.clean_weights() # Ensure the number of columns in historical_d_return matches the number of assets historical_d_return = historical_d_return.iloc[:, :len(cleaned_weights_bl)] # Calculate portfolio performance for Black-Litterman Optimal port_returns_bl = (historical_d_return * cleaned_weights_bl).sum(axis=1) # Add the Black-Litterman Optimal returns to port_returns DataFrame port_daily_returns['Black-Litterman Optimal'] = port_returns_bl