Data Lab 3 - Elina Ly

!pip install yfinance import yfinance as yf import pandas as pd import numpy as np from scipy.optimize import minimize # Define the stock symbols stock_symbols = ['PG', 'KO', 'JNJ', 'MCD'] # Define the 5-year period start_date = '2018-09-01' end_date = '2023-09-01' # Download historical stock data from Yahoo Finance stock_data = yf.download(stock_symbols, start=start_date, end=end_date) # Calculate daily returns for each stock stock_returns = stock_data['Adj Close'].pct_change().dropna() # Calculate expected returns and covariance matrix expected_returns = stock_returns.mean() cov_matrix = stock_returns.cov() # Define a function to calculate portfolio returns and volatility def portfolio_metrics(weights, expected_returns, cov_matrix): portfolio_return = np.sum(weights * expected_returns) portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights))) return portfolio_return, portfolio_volatility # Define the negative Sharpe ratio as an optimization objective def negative_sharpe(weights, expected_returns, cov_matrix, risk_free_rate): portfolio_return, portfolio_volatility = portfolio_metrics(weights, expected_returns, cov_matrix) sharpe_ratio = (portfolio_return - risk_free_rate) / portfolio_volatility return -sharpe_ratio # Define the portfolio optimization constraints (weights sum to 1) constraints = ({'type': 'eq', 'fun': lambda weights: np.sum(weights) - 1}) # Define the bounds for portfolio weights (0 <= weight <= 1) bounds = tuple((0, 1) for asset in range(len(stock_symbols))) # Initial guess for portfolio weights (equal weights) initial_weights = [1 / len(stock_symbols) for stock in stock_symbols] # Calculate the risk-free rate (use a benchmark like the 10-year Treasury yield) risk_free_rate = 0.015 # Assume 1.5% annual risk-free rate # Optimize for maximum Sharpe ratio portfolio max_sharpe_portfolio = minimize(negative_sharpe, initial_weights, args=(expected_returns, cov_matrix, risk_free_rate), method='SLSQP', bounds=bounds, constraints=constraints) max_sharpe_weights = max_sharpe_portfolio.x # Define a function to calculate portfolio volatility (for minimum volatility portfolio) def portfolio_volatility(weights, cov_matrix): portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights))) return portfolio_volatility # Optimize for minimum volatility portfolio min_volatility_portfolio = minimize(portfolio_volatility, initial_weights, args=(cov_matrix,), method='SLSQP', bounds=bounds, constraints=constraints) min_volatility_weights = min_volatility_portfolio.x # Create an equally-weighted portfolio num_stocks = len(stock_symbols) weights = np.full(num_stocks, 1/num_stocks) portfolio_returns_eq = (stock_returns * weights).sum(axis=1) # Calculate cumulative returns for all three portfolios cumulative_returns_eq = (1 + portfolio_returns_eq).cumprod() cumulative_returns_max_sharpe = (1 + (stock_returns * max_sharpe_weights).sum(axis=1)).cumprod() cumulative_returns_min_volatility = (1 + (stock_returns * min_volatility_weights).sum(axis=1)).cumprod() # Create a DataFrame to store the daily and cumulative returns portfolio_returns_df = pd.DataFrame({ 'Date': stock_returns.index, 'Equally-Weighted Portfolio': portfolio_returns_eq.values, 'Max Sharpe Portfolio': (stock_returns * max_sharpe_weights).sum(axis=1).values, 'Min Volatility Portfolio': (stock_returns * min_volatility_weights).sum(axis=1).values, 'Cumulative Returns (Equally-Weighted Portfolio)': cumulative_returns_eq.values, 'Cumulative Returns (Max Sharpe Portfolio)': cumulative_returns_max_sharpe.values, 'Cumulative Returns (Min Volatility Portfolio)': cumulative_returns_min_volatility.values }) # Set the date column as the index portfolio_returns_df.set_index('Date', inplace=True) # Display the DataFrame print(portfolio_returns_df)

import matplotlib.pyplot as plt # Function to calculate drawdowns def calculate_drawdown(cumulative_returns): max_return = cumulative_returns[0] drawdowns = [] for value in cumulative_returns: if value > max_return: max_return = value drawdown = (value - max_return) / max_return drawdowns.append(drawdown) return drawdowns # Calculate drawdowns for each portfolio drawdown_eq = calculate_drawdown(cumulative_returns_eq) drawdown_max_sharpe = calculate_drawdown(cumulative_returns_max_sharpe) drawdown_min_volatility = calculate_drawdown(cumulative_returns_min_volatility) # Plot the drawdowns plt.figure(figsize=(12, 6)) plt.plot(portfolio_returns_df.index, drawdown_eq, label='Equally-Weighted Portfolio', linewidth=2) plt.plot(portfolio_returns_df.index, drawdown_max_sharpe, label='Max Sharpe Portfolio', linewidth=2) plt.plot(portfolio_returns_df.index, drawdown_min_volatility, label='Min Volatility Portfolio', linewidth=2) plt.fill_between(portfolio_returns_df.index, drawdown_eq, alpha=0.3) plt.fill_between(portfolio_returns_df.index, drawdown_max_sharpe, alpha=0.3) plt.fill_between(portfolio_returns_df.index, drawdown_min_volatility, alpha=0.3) plt.title('Drawdown Behavior of Portfolios (2018-2023)') plt.xlabel('Date') plt.ylabel('Drawdown') plt.legend() plt.grid(True) plt.show()

import matplotlib.pyplot as plt import scipy.stats as stats # Define the confidence level (99%) confidence_level = 0.99 # Calculate the empirical VaR using historical returns empirical_var_eq = np.percentile(portfolio_returns_eq, (1 - confidence_level) * 100) empirical_var_max_sharpe = np.percentile((stock_returns * max_sharpe_weights).sum(axis=1), (1 - confidence_level) * 100) empirical_var_min_volatility = np.percentile((stock_returns * min_volatility_weights).sum(axis=1), (1 - confidence_level) * 100) # Calculate the theoretical VaR assuming normal distribution mean_portfolio_return = portfolio_returns_eq.mean() std_portfolio_return = portfolio_returns_eq.std() theoretical_var_eq = stats.norm.ppf(1 - confidence_level, loc=mean_portfolio_return, scale=std_portfolio_return) mean_max_sharpe_return = (stock_returns * max_sharpe_weights).sum(axis=1).mean() std_max_sharpe_return = (stock_returns * max_sharpe_weights).sum(axis=1).std() theoretical_var_max_sharpe = stats.norm.ppf(1 - confidence_level, loc=mean_max_sharpe_return, scale=std_max_sharpe_return) mean_min_volatility_return = (stock_returns * min_volatility_weights).sum(axis=1).mean() std_min_volatility_return = (stock_returns * min_volatility_weights).sum(axis=1).std() theoretical_var_min_volatility = stats.norm.ppf(1 - confidence_level, loc=mean_min_volatility_return, scale=std_min_volatility_return) # Create graphs to visualize VaR plt.figure(figsize=(12, 6)) plt.hist(portfolio_returns_eq, bins=50, density=True, alpha=0.5, label='Empirical (Equally-Weighted Portfolio)') plt.hist((stock_returns * max_sharpe_weights).sum(axis=1), bins=50, density=True, alpha=0.5, label='Empirical (Max Sharpe Portfolio)') plt.hist((stock_returns * min_volatility_weights).sum(axis=1), bins=50, density=True, alpha=0.5, label='Empirical (Min Volatility Portfolio)') plt.axvline(empirical_var_eq, color='red', linestyle='--', label=f'Empirical VaR (99%) = {empirical_var_eq:.2%}') plt.axvline(empirical_var_max_sharpe, color='green', linestyle='--', label=f'Empirical VaR (99%) = {empirical_var_max_sharpe:.2%}') plt.axvline(empirical_var_min_volatility, color='blue', linestyle='--', label=f'Empirical VaR (99%) = {empirical_var_min_volatility:.2%}') plt.axvline(theoretical_var_eq, color='purple', linestyle='--', label=f'Theoretical VaR (99%) = {theoretical_var_eq:.2%}') plt.axvline(theoretical_var_max_sharpe, color='orange', linestyle='--', label=f'Theoretical VaR (99%) = {theoretical_var_max_sharpe:.2%}') plt.axvline(theoretical_var_min_volatility, color='brown', linestyle='--', label=f'Theoretical VaR (99%) = {theoretical_var_min_volatility:.2%}') plt.title('Empirical and Theoretical VaR (99%) of Portfolios') plt.xlabel('Portfolio Returns') plt.ylabel('Frequency') plt.legend() plt.grid(True) plt.show()

from scipy import stats # Calculate the mean returns of the maximum Sharpe portfolio and equally weighted portfolio mean_return_max_sharpe = (stock_returns * max_sharpe_weights).sum(axis=1).mean() mean_return_equally_weighted = portfolio_returns_eq.mean() # Calculate the standard errors of the means std_error_max_sharpe = (stock_returns * max_sharpe_weights).sum(axis=1).std() / np.sqrt(len(portfolio_returns_eq)) std_error_equally_weighted = portfolio_returns_eq.std() / np.sqrt(len(portfolio_returns_eq)) # Perform a two-sample t-test t_statistic, p_value = stats.ttest_ind((stock_returns * max_sharpe_weights).sum(axis=1), portfolio_returns_eq, equal_var=False) # Set the significance level (alpha) alpha = 0.05 # Check if the p-value is less than alpha if p_value < alpha: print("Reject the null hypothesis") print("There is a statistically significant difference in means") else: print("Fail to reject the null hypothesis") print("There is no statistically significant difference in means") # Display the t-statistic and p-value print(f"t-statistic: {t_statistic:.4f}") print(f"p-value: {p_value:.4f}")

from scipy import stats # Calculate the Sharpe ratios for both portfolios sharpe_ratio_max_sharpe = (mean_max_sharpe_return - risk_free_rate) / std_max_sharpe_return sharpe_ratio_equally_weighted = (mean_return_equally_weighted - risk_free_rate) / portfolio_returns_eq.std() # Perform a two-sample t-test t_statistic, p_value = stats.ttest_ind([sharpe_ratio_max_sharpe], [sharpe_ratio_equally_weighted]) # Set the significance level (alpha) alpha = 0.05 # Check if the p-value is less than alpha if p_value < alpha: print("Reject the null hypothesis") print("There is a statistically significant difference in Sharpe ratios") else: print("Fail to reject the null hypothesis") print("There is no statistically significant difference in Sharpe ratios") # Display the t-statistic and p-value print(f"t-statistic: {t_statistic:.4f}") print(f"p-value: {p_value:.4f}")

from scipy import stats # VaR values at 99% confidence level for both portfolios var_max_sharpe = empirical_var_max_sharpe var_equally_weighted = empirical_var_eq # Perform a two-sample t-test t_statistic, p_value = stats.ttest_ind([var_max_sharpe], [var_equally_weighted]) # Set the significance level (alpha) alpha = 0.05 # Check if the p-value is less than alpha if p_value < alpha: print("Reject the null hypothesis") print("There is a statistically significant difference in VaR") else: print("Fail to reject the null hypothesis") print("There is no statistically significant difference in VaR") # Display the t-statistic and p-value print(f"t-statistic: {t_statistic:.4f}") print(f"p-value: {p_value:.4f}")