add portfolio builder

pages/2_Portfolio_Builder.py

@@ -0,0 +1,179 @@
+import pandas as pd
+from openbb import obb
+import riskfolio as rp
+import os
+from dotenv import load_dotenv
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+import plotly.graph_objs as go
+import plotly.tools as tls
+from plotly.subplots import make_subplots
+import plotly.figure_factory as ff
+import streamlit as st
+
+load_dotenv()
+
+from openbb import obb
+obb.account.login(pat=os.environ['open_bb_pat'])
+
+
+# take stock inputs 
+tickers = [
+    "XLE", "XLF", "XLU", "XLI", "GDX", 
+    "XLK", "XLV", "XLY", "XLP", "XLB", 
+    "XOP", "IYR", "XHB", "ITB", "VNQ", 
+    "GDXJ", "IYE", "OIH", "XME", "XRT", 
+    "SMH", "IBB", "KBE", "KRE", "XTL", 
+]
+
+start_date = '2023-01-01'
+end_date = '2024-01-01'
+
+data = (
+    obb
+    .equity
+    .price
+    .historical(tickers, start_date=start_date, end_date=end_date, provider="yfinance")
+    .to_df()
+    .pivot(columns="symbol", values="close")
+)
+
+returns = data.pct_change().dropna()
+
+#  -------------------------- (Efficient Frontier Calculation) -------------------------------- #
+st.title('Efficient Frontier Portfolio')
+st.write("The efficient frontier is a set of optimal portfolios that offer the highest expected return for a defined level of risk or the lowest risk for a given level of expected return. Portfolios that lie below the efficient frontier are sub-optimal because they do not provide enough return for the level of risk. Portfolios that cluster to the right of the efficient frontier are also sub-optimal because they have a higher level of risk for the defined rate of return.")
+
+port = rp.Portfolio(returns=returns)
+
+# Step 2: Set portfolio optimization model
+port.assets_stats(model='hist')  # Using historical data for estimation
+
+# Step 3: Configure the optimization model and calculate the efficient frontier
+ef = port.efficient_frontier(model='Classic', rm='MV', points=50, rf=0.0406, hist=True)
+w1 = port.optimization(model='Classic', rm='MV', obj='Sharpe', rf=0.0, l=0, hist=True)
+
+mu = port.mu  # Expected returns
+cov = port.cov  # Covariance matrix
+
+
+
+# ----------------------------  (Portfolio Statistics) -------------------------------- #
+
+st.write('**Portfolio Statistics Optimized for Max Sharpe Ratio:**')
+spy_prices = obb.equity.price.historical(symbol = "spy", provider="yfinance", start_date=start_date, end_date=end_date).to_df()
+
+# Calculate daily returns
+# Ensure you're using the adjusted close prices for accurate return calculation
+benchmark_returns = spy_prices['close'].pct_change().dropna()
+
+port.rf = 0.0406  # Risk-free rate
+portfolio_return = np.dot(w1, mu)
+
+# market return
+spy_daily_return = benchmark_returns
+spy_expected_return = spy_daily_return.mean()
+
+# portfolio's beta
+covariance = returns.apply(lambda x: x.cov(spy_daily_return))
+spy_variance = spy_daily_return.var()
+beta_values = covariance / spy_variance
+portfolio_beta = np.dot(w1['weights'], beta_values)
+st.write('Portfolio Beta: ', np.round(portfolio_beta,3))
+
+# jensens alpha
+expected_return = port.rf + portfolio_beta * (spy_daily_return - port.rf)
+st.write('Jensen\'s Alpha: ', np.round(expected_return.iloc[-1],3))
+
+# treynor ratio
+treynor_ratio = (expected_return - port.rf) / portfolio_beta
+st.write('Treynor Ratio: ', np.round(treynor_ratio.iloc[-1],3))
+
+# Portfolio volatility
+portfolio_stddev = np.sqrt(np.dot(pd.Series(w1['weights']).T, np.dot(covariance, w1['weights'])))
+
+# Sharpe Ratio, adjusted for the risk-free rate
+sharpe_ratio = (expected_return.iloc[-1] - port.rf) / np.mean(portfolio_stddev[portfolio_stddev != 0])
+st.write('Sharpe Ratio: ', np.round(sharpe_ratio, 3))
+
+# -------------------------- (Plotting) -------------------------------- #
+# Step 4: Plot the efficient frontier
+fig_ef, ax_ef = plt.subplots()
+ax_ef = rp.plot_frontier(mu=mu, cov=cov, returns=port.returns, w=w1, rm='MV', w_frontier=ef, marker='*', label='Optimal Portfolio - Max. Sharpe' ,s=16)
+st.pyplot(fig_ef)
+
+st.write('**Asset Mix of Optimized Portfolio:**')
+st.dataframe(w1.T, use_container_width=True)
+
+# corr matrix
+fig, ax = plt.subplots()
+corr = returns.corr()
+
+# Create a heatmap
+heatmap = go.Heatmap(z=corr.values, x=corr.columns, y=corr.index, colorscale='RdYlBu')
+layout = go.Layout(title='Correlation Matrix', autosize=True, width=1200, height=1200)
+fig = go.Figure(data=[heatmap], layout=layout)
+
+st.plotly_chart(fig)
+
+
+
+#  -------------------------- (HRP Portfolio) -------------------------------- #
+st.title('Hierarchical Risk Parity Portfolio')
+st.write("""
+HRP is unlike traditional portfolio optimization methods. It can create an optimized portfolio when the covariance matrix is ill-degenerated or singular. This is impossible for quadratic optimizers.
+Research has shown HRP to deliver lower out-of-sample variance than traditional optimization methods.
+""")
+
+fig1, ax1 = plt.subplots()
+ax1 = rp.plot_clusters(returns=returns,
+                      codependence='pearson',
+                      linkage='single',
+                      k=None,
+                      max_k=10,
+                      leaf_order=True,
+                      dendrogram=True,
+                      ax=None)
+
+st.pyplot(fig1)
+
+port = rp.HCPortfolio(returns=returns)
+w = port.optimization(
+    model="HRP",
+    codependence="pearson",
+    rm="MV", # minimum variance
+    rf=0.05,
+    linkage="single",
+    max_k=10,
+    leaf_order=True,
+)
+
+fig2, ax2 = plt.subplots()
+ax2 = rp.plot_pie(
+    w=w,
+    title="HRP Naive Risk Parity",
+    others=0.05,
+    nrow=25,
+    cmap="tab20",
+    height=8,
+    width=10,
+    ax=None,
+)
+st.pyplot(fig2)
+
+fig3, ax3 = plt.subplots()
+ax3 = rp.plot_risk_con(
+    w=w,
+    cov=returns.cov(),
+    returns=returns,
+    rm="MV",
+    rf=0,
+    alpha=0.05,
+    color="tab:blue",
+    height=6,
+    width=10,
+    t_factor=252,
+    ax=None,
+)
+st.pyplot(fig3)

requirements.txt

@@ -20,4 +20,6 @@ streamlit==1.22.0
 regex
 yfinance==0.2.28
 torch
-python-dotenv
+python-dotenv
+openbb
+riskfolio-lib