Update app.py

app.py

@@ -11,7 +11,12 @@ import matplotlib.pyplot as plt
 
 # Helper functions
 def fetch_stock_data(tickers, start_date, end_date):
-    return yf.download(tickers, start=start_date, end=end_date)['Adj Close']
+    data = yf.download(tickers, start=start_date, end=end_date, auto_adjust=False)['Adj Close']
+    if isinstance(data.columns, pd.MultiIndex):
+        data.columns = data.columns.get_level_values(0)
+    if data.empty:
+        raise ValueError(f"No data fetched for {tickers} from {start_date} to {end_date}.")
+    return data
 
 def plot_efficient_frontier(mean_returns, cov_matrix, title):
     ef = EfficientFrontier(mean_returns, cov_matrix)
@@ -259,7 +264,6 @@ def optimize_max_quadratic_utility(mean_returns, cov_matrix, risk_aversion):
     return ef.clean_weights()
 
 # Streamlit app
-st.set_page_config(page_title="Portfolio Optimization", layout="wide")
 st.title('Portfolio Optimization Methods')
 st.markdown("""
 This tool allows you to optimize a portfolio of stocks using different optimization methods. You can choose between optimization methods simply by selecting the method, enterING the stock tickers, and setting the parameters. Click the "Run" button to see the results.
@@ -319,7 +323,6 @@ if selected == "Multi-Objective Optimization":
 with st.expander("Methodology and Formulas", expanded=False):
     st.markdown("""
     #### Formulas:
-
     **Expected Return**:
     """)
     st.latex(r"""
@@ -356,9 +359,7 @@ with st.expander("Methodology and Formulas", expanded=False):
 
     st.markdown("""
     #### Mathematical Optimization Process
-
     The optimization process involves solving a mathematical problem to find the portfolio weights \( wi \) that best meet the selected objectives. The optimization problem can be formulated as follows:
-
     **Objective Function**:
     Minimize or maximize a weighted sum of multiple objectives. The overall objective function can be expressed as:
     """)
@@ -370,7 +371,6 @@ with st.expander("Methodology and Formulas", expanded=False):
     where:
     - \( \lambda_i \) are the weights assigned to each objective.
     - \( \mathbf{w} \) is the vector of portfolio weights.
-
     **Constraints**:
     1. The sum of the portfolio weights must equal 1 (fully invested portfolio):
     """)
@@ -387,9 +387,7 @@ with st.expander("Methodology and Formulas", expanded=False):
 
     st.markdown("""
     3. Additional constraints based on user preferences or regulatory requirements can also be included.
-
     The optimization is performed using numerical methods, i.e. using the Sequential Least Squares Programming (SLSQP) algorithm. This algorithm iteratively adjusts the portfolio weights to find the optimal solution that satisfies the constraints and minimizes (or maximizes) the objective function.
-
     """)
 
 st.sidebar.header("Optimization Parameters")
@@ -441,8 +439,12 @@ if 'multi_objective_result' in st.session_state:
     st.plotly_chart(fig_weights)
 
     portfolio_returns = returns.dot(optimal_weights)
-    sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-    sp500_returns = sp500.pct_change().dropna()
+    sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+    if isinstance(sp500.columns, pd.MultiIndex):
+        sp500.columns = sp500.columns.get_level_values(0)
+    if sp500.empty:
+        raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+    sp500_returns = sp500['Adj Close'].pct_change().dropna()
     equal_weighted_returns = returns.mean(axis=1)
     
     fig_cumulative_returns = plot_cumulative_returns(portfolio_returns,
@@ -479,7 +481,6 @@ elif selected == "Robust Optimization":
         #### Concept:
         The covariance matrix can be unstable due to limited data or market volatility.         
         Robust Optimization addresses this by applying techniques such as covariance shrinkage to produce a more stable covariance matrix.
-
         #### Regularization Technique:
         One common approach in Robust Optimization is the Ledoit-Wolf shrinkage method, which adjusts the sample covariance matrix towards a more structured target, such as the identity matrix. 
         **Covariance Shrinkage**:
@@ -518,7 +519,6 @@ elif selected == "Robust Optimization":
         """)
         st.markdown("""
         #### Practical Benefits:
-
         - **Stability**: By reducing the impact of outliers and estimation errors, Robust Optimization produces more stable portfolios.
         - **Performance**: It can improve portfolio performance by avoiding extreme weights that might result from noisy data.
         - **Applicability**: Suitable for environments with high market volatility or limited historical data.
@@ -556,8 +556,12 @@ elif selected == "Robust Optimization":
         st.plotly_chart(fig_weights)
 
         portfolio_returns_robust = returns.dot(np.array(list(cleaned_weights_robust.values())))
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
         
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns_robust,
@@ -593,7 +597,6 @@ elif selected == "Mean-Variance Optimization":
         #### Concept:
         The Mean-Variance Optimization approach is based on the idea of creating a portfolio that provides the maximum expected return for a given level of risk or, equivalently, the minimum risk for a given level of expected return. 
         This is achieved by selecting the proportions of various assets in the portfolio.
-
         #### Sharpe Ratio:
         The Sharpe ratio is a measure of the risk-adjusted return of a portfolio. It is calculated as:
         """)
@@ -605,10 +608,8 @@ elif selected == "Mean-Variance Optimization":
         - \( \mathbb{E}[R_p] \) is the expected return of the portfolio.
         - \( R_f \) is the risk-free rate.
         - \( \sigma_p \) is the standard deviation of the portfolio returns.
-
         #### Mathematical Optimization Process:
         The optimization problem can be formulated as follows:
-
         **Objective Function**:
         """)
         st.latex(r"""
@@ -619,7 +620,6 @@ elif selected == "Mean-Variance Optimization":
         - \( w \) is the vector of portfolio weights.
         - \( \mu \) is the vector of expected asset returns.
         - \( \Sigma \) is the covariance matrix of asset returns.
-
         **Constraints**:
         1. The sum of the portfolio weights must equal 1 (fully invested portfolio):
         """)
@@ -634,7 +634,6 @@ elif selected == "Mean-Variance Optimization":
         """)
         st.markdown("""
         #### Benefits of Mean-Variance Optimization:
-
         - **Risk Management**: It helps in managing the trade-off between risk and return by considering the covariance among asset returns.
         - **Diversification**: By incorporating the covariance matrix, it promotes diversification and reduces unsystematic risk.
         - **Simplicity**: It provides a straightforward framework for constructing efficient portfolios.
@@ -674,8 +673,12 @@ elif selected == "Mean-Variance Optimization":
         st.plotly_chart(fig_weights)
 
         portfolio_returns = returns.dot(optimal_weights)
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
         
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns,
@@ -715,7 +718,6 @@ elif selected == "Black-Litterman Model":
         st.markdown("""
         #### Concept:
         The Black-Litterman Model starts with the market equilibrium returns, which are implied by market capitalizations and a given risk aversion coefficient. Investors can then specify their own views on expected returns for certain assets or combinations of assets.
-
         #### Market Equilibrium Returns:
         The market equilibrium returns, \( \Pi \), are given by:
         """)
@@ -727,7 +729,6 @@ elif selected == "Black-Litterman Model":
         - \( \delta \) is the risk aversion coefficient.
         - \( \Sigma \) is the covariance matrix of asset returns.
         - \( w_{mkt} \) is the vector of market capitalization weights.
-
         #### Investor Views:
         Investor views are expressed in the form of a matrix \( P \) and a vector \( Q \):
         """)
@@ -739,7 +740,6 @@ elif selected == "Black-Litterman Model":
         - \( P \) is the matrix that identifies the assets involved in each view.
         - \( \mu \) is the vector of expected returns.
         - \( Q \) is the vector of view returns.
-
         #### Adjusted Expected Returns:
         The adjusted expected returns, \( \mu \), are then calculated as:
         """)
@@ -750,10 +750,8 @@ elif selected == "Black-Litterman Model":
         Where:
         - \( \tau \) is a scalar representing the uncertainty in the prior estimates.
         - \( \Omega \) is the diagonal covariance matrix of the error terms in the views.
-
         #### Optimization:
         Once the adjusted expected returns, \( \mu \), are obtained, we can apply mean-variance optimization to find the optimal portfolio weights.
-
         **Objective Function**:
         """)
         st.latex(r"""
@@ -774,7 +772,6 @@ elif selected == "Black-Litterman Model":
         """)
         st.markdown("""
         #### Benefits of the Black-Litterman Model:
-
         - **Flexibility**: Incorporates investor views into the optimization process.
         - **Stability**: Produces more stable and intuitive expected returns than traditional mean-variance optimization.
         - **Theoretical Foundation**: Combines the principles of modern portfolio theory with practical investor insights.
@@ -792,7 +789,12 @@ elif selected == "Black-Litterman Model":
         cov_matrix = risk_models.sample_cov(data)
 
         # Download market data for market capitalization weights (here using S&P 500 as proxy)
-        market_data = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
+        market_data = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(market_data.columns, pd.MultiIndex):
+            market_data.columns = market_data.columns.get_level_values(0)
+        if market_data.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        market_data = market_data['Adj Close']
 
         # Calculate market-implied risk aversion
         delta = black_litterman.market_implied_risk_aversion(market_data)
@@ -838,8 +840,12 @@ elif selected == "Black-Litterman Model":
         st.plotly_chart(fig_weights)
 
         portfolio_returns_bl = returns.dot(optimal_weights_bl)
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
         
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns_bl,
@@ -890,10 +896,8 @@ elif selected == "Hierarchical Risk Parity":
         st.markdown("""
         Where:
         - \( \rho_{i,j} \) is the correlation coefficient between assets \( i \) and \( j \).
-
         #### Quasi-Diagonalization:
         The covariance matrix \( \Sigma \) is reordered to a block-diagonal form using the clustering information. This step ensures that the assets with higher correlations are grouped together.
-
         #### Recursive Bisection:
         Risk is allocated recursively using the following steps:
         1. **Top-Level Allocation**:
@@ -905,13 +909,11 @@ elif selected == "Hierarchical Risk Parity":
         st.markdown("""
         2. **Sub-Level Allocation**:
            The risk within each cluster is further split recursively until the individual assets are reached.
-
         This recursive process ensures that risk is allocated evenly across all clusters and individual assets.
         """)
 
         st.markdown("""
         #### Benefits of HRP:
-
         - **Improved Diversification**: By clustering similar assets and allocating risk evenly, HRP achieves better diversification compared to traditional methods.
         - **Reduced Risk Concentration**: HRP avoids concentrating risk in highly correlated assets, resulting in a more balanced portfolio.
         - **Robustness**: HRP is less sensitive to estimation errors in the covariance matrix, making it a robust method for portfolio optimization.
@@ -949,8 +951,12 @@ elif selected == "Hierarchical Risk Parity":
         st.plotly_chart(fig_weights)
 
         portfolio_returns_hrp = returns.dot(optimal_weights_hrp)
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
 
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns_hrp,
@@ -998,10 +1004,8 @@ elif selected == "Maximum Diversification":
         - \( \sigma_i \) is the volatility of asset \( i \).
         - \( \Sigma \) is the covariance matrix of asset returns.
         - \( w \) is the weight vector of the portfolio.
-
         #### Objective:
         The objective of the Maximum Diversification Portfolio is to maximize this diversification ratio. By doing so, the portfolio aims to achieve the highest possible diversification benefit, reducing the overall portfolio risk.
-
         #### Mathematical Formulation:
         The optimization problem can be formulated as:
         """)
@@ -1011,21 +1015,17 @@ elif selected == "Maximum Diversification":
         """)
         st.markdown("""
         This ensures that the sum of the weights is equal to 1 (fully invested portfolio) and that all weights are non-negative (long-only portfolio).
-
         #### Steps Involved:
         1. **Calculate Individual Volatilities**:
            Compute the volatility (\( \sigma_i \)) for each asset in the portfolio.
-
         2. **Compute the Covariance Matrix**:
            Calculate the covariance matrix (\( \Sigma \)) of asset returns.
-
         3. **Optimize the Diversification Ratio**:
            Use optimization techniques to find the weight vector (\( w \)) that maximizes the diversification ratio, subject to the constraints.
         """)
 
         st.markdown("""
         #### Benefits:
-
         - **Enhanced Diversification**: By focusing on maximizing the diversification ratio, this method ensures that the portfolio is well-diversified, reducing the impact of any single asset on the overall portfolio risk.
         - **Reduced Portfolio Risk**: By maximizing the diversification benefit, the overall portfolio risk is minimized compared to other traditional optimization methods.
         """)
@@ -1064,8 +1064,12 @@ elif selected == "Maximum Diversification":
         st.plotly_chart(fig_weights)
 
         portfolio_returns_mdp = returns.dot(optimal_weights_mdp)
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
 
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns_mdp,
@@ -1109,7 +1113,6 @@ elif selected == "Maximum Sharpe Ratio":
         - \( R_p \) is the expected portfolio return.
         - \( R_f \) is the risk-free rate.
         - \( \sigma_p \) is the portfolio's standard deviation (volatility).
-
         #### Objective:
         The objective of the Maximum Sharpe Ratio Portfolio is to find the portfolio weights that maximize the Sharpe ratio. This ensures the highest possible return for a given level of risk.
         """)
@@ -1149,8 +1152,12 @@ elif selected == "Maximum Sharpe Ratio":
         st.plotly_chart(fig_weights)
 
         portfolio_returns_msr = returns.dot(np.array(list(optimal_weights_msr.values())))
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
 
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns_msr,
@@ -1185,7 +1192,6 @@ elif selected == "Equal Risk Contribution":
         st.markdown("""
         #### Concept:
         The key idea is to balance the contribution of each asset to the total portfolio risk, such that the risk contribution from each asset is equal.
-
         #### Objective:
         The objective of the ERC Portfolio is to find the weights of the assets that equalize their risk contributions. The risk contribution of an asset \( i \) to the total portfolio risk is given by:
         """)
@@ -1197,7 +1203,6 @@ elif selected == "Equal Risk Contribution":
         - \( RC_i \) is the risk contribution of asset \( i \).
         - \( w_i \) is the weight of asset \( i \).
         - \( \sigma_p \) is the portfolio's standard deviation (volatility).
-
         #### Mathematical Formulation:
         The optimization problem can be formulated as:
         """)
@@ -1209,7 +1214,6 @@ elif selected == "Equal Risk Contribution":
         Where:
         - \( n \) is the number of assets.
         - The goal is to minimize the sum of squared deviations of each asset's risk contribution from the average risk contribution \( \frac{\sigma_p}{n} \).
-
         #### Steps Involved:
         1. **Estimate Expected Returns and Covariance Matrix**:
            Compute the expected returns (\( \mu \)) and the covariance matrix (\( \Sigma \)) for the assets.
@@ -1221,7 +1225,6 @@ elif selected == "Equal Risk Contribution":
 
         st.markdown("""
         #### Benefits:
-
         - **Balanced Risk Allocation**: Ensures that no single asset dominates the portfolio risk, leading to a more balanced and diversified portfolio.
         - **Risk Management**: Helps in managing the overall portfolio risk by spreading it equally across all assets.
         """)
@@ -1255,8 +1258,12 @@ elif selected == "Equal Risk Contribution":
         st.plotly_chart(fig_weights)
 
         portfolio_returns_erc = returns.dot(np.array(list(optimal_weights_erc.values())))
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
 
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns_erc,
@@ -1291,10 +1298,8 @@ elif selected == "CVaR Minimization":
         st.markdown("""
         #### Concept:
         Conditional Value at Risk (CVaR) is a risk assessment measure that quantifies the expected loss in the worst-case scenarios beyond a certain confidence level. It provides a more comprehensive risk measure compared to Value at Risk (VaR).
-
         #### Objective:
         The objective of the CVaR Minimization Portfolio is to find the weights of the assets that minimize the CVaR at a given confidence level.
-
         #### Mathematical Formulation:
         The optimization problem can be formulated as:
         """)
@@ -1309,7 +1314,6 @@ elif selected == "CVaR Minimization":
         - \( \alpha \) is the confidence level (e.g., 95%).
         - \( T \) is the number of observations.
         - \( L_t(w) \) is the loss of the portfolio at time \( t \).
-
         #### Steps Involved:
         1. **Estimate Expected Returns and Covariance Matrix**:
            Compute the expected returns (\( \mu \)) and the covariance matrix (\( \Sigma \)) for the assets.
@@ -1354,8 +1358,12 @@ elif selected == "CVaR Minimization":
         st.plotly_chart(fig_weights)
 
         portfolio_returns_cvar = returns.dot(np.array(list(optimal_weights_cvar.values())))
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
 
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns_cvar,
@@ -1390,10 +1398,8 @@ elif selected == "Maximum Return":
         st.markdown("""
         #### Concept:
         The Maximum Return Portfolio aims to achieve the highest possible return by investing in assets that have the highest expected returns. This approach does not take into account the risk or volatility associated with the assets.
-
         #### Objective:
         The objective of the Maximum Return Portfolio is to find the weights of the assets that maximize the expected return.
-
         #### Mathematical Formulation:
         The optimization problem can be formulated as:
         """)
@@ -1406,7 +1412,6 @@ elif selected == "Maximum Return":
         - \( w \) is the weight vector of the assets.
         - \( \mu \) is the expected return vector of the assets.
         - \( n \) is the number of assets.
-
         #### Steps Involved:
         1. **Estimate Expected Returns**:
            Compute the expected returns (\( \mu \)) for each asset.
@@ -1416,12 +1421,9 @@ elif selected == "Maximum Return":
 
         st.markdown("""
         #### Benefits:
-
         - **High Potential Returns**: Focuses on achieving the highest possible returns.
         - **Simple Approach**: Easy to understand and implement.
-
         #### Drawbacks:
-
         - **Ignores Risk**: Does not consider the risk or volatility associated with the assets.
         - **Potential for High Volatility**: Can result in a highly volatile portfolio.
         """)
@@ -1455,8 +1457,12 @@ elif selected == "Maximum Return":
         st.plotly_chart(fig_weights)
 
         portfolio_returns_max_return = returns.dot(np.array(list(optimal_weights_max_return.values())))
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
 
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns_max_return,
@@ -1491,7 +1497,6 @@ elif selected == "Maximum Quadratic Utility":
         st.markdown("""
         #### Concept:
         The Maximum Quadratic Utility Portfolio aims to find the optimal portfolio that maximizes an investor's utility, which is a measure of satisfaction or preference. This approach takes into account both the expected return and the risk of the portfolio, weighted by a risk aversion coefficient.
-
         #### Objective:
         The objective of the Maximum Quadratic Utility Portfolio is to maximize the utility function, which is defined as:
         """)
@@ -1505,7 +1510,6 @@ elif selected == "Maximum Quadratic Utility":
         - \( \mu \) is the expected return vector of the assets.
         - \( \Sigma \) is the covariance matrix of the asset returns.
         - \( \lambda \) is the risk aversion coefficient.
-
         #### Steps Involved:
         1. **Estimate Expected Returns and Covariance Matrix**:
            Compute the expected returns (\( \mu \)) and the covariance matrix (\( \Sigma \)) for the assets.
@@ -1517,12 +1521,9 @@ elif selected == "Maximum Quadratic Utility":
 
         st.markdown("""
         #### Benefits:
-
         - **Balances Return and Risk**: Provides a trade-off between maximizing returns and minimizing risk.
         - **Customizable Risk Tolerance**: Allows adjustment of the risk aversion coefficient to match the investor's risk preference.
-
         #### Drawbacks:
-
         - **Requires Accurate Estimates**: The effectiveness of the method depends on accurate estimates of expected returns and the covariance matrix.
         - **Complexity**: More complex to implement compared to simpler methods like Maximum Return Portfolio.
         """)
@@ -1557,8 +1558,12 @@ elif selected == "Maximum Quadratic Utility":
         st.plotly_chart(fig_weights)
 
         portfolio_returns_mqu = returns.dot(np.array(list(optimal_weights_mqu.values())))
-        sp500 = yf.download('^GSPC', start=start_date, end=end_date)['Adj Close']
-        sp500_returns = sp500.pct_change().dropna()
+        sp500 = yf.download('^GSPC', start=start_date, end=end_date, auto_adjust=False)
+        if isinstance(sp500.columns, pd.MultiIndex):
+            sp500.columns = sp500.columns.get_level_values(0)
+        if sp500.empty:
+            raise ValueError(f"No S&P 500 data fetched from {start_date} to {end_date}.")
+        sp500_returns = sp500['Adj Close'].pct_change().dropna()
         equal_weighted_returns = returns.mean(axis=1)
 
         fig_cumulative_returns = plot_cumulative_returns(portfolio_returns_mqu,
@@ -1600,4 +1605,4 @@ hide_streamlit_style = """
 footer {visibility: hidden;}
 </style>
 """
-st.markdown(hide_streamlit_style, unsafe_allow_html=True)
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)