Update app.py

app.py

@@ -1,11 +1,3 @@
-#import numpy as np
-#np.core.multiarray  # Ensure numpy's C API is loaded
-#np._import_array()  # Force initialization of numpy's C API
-#import numpy.core.multiarray
-
-# app.py
-import init  # Ensure numpy's C API is initialized
-
 import numpy as np
 import streamlit as st
 import pandas as pd
@@ -26,93 +18,70 @@ It simulates various market scenarios to analyze the dependencies between differ
 Users can assess potential outcomes in terms of best, worst, and mean case scenarios.
 """)
 
-st.sidebar.subheader("How to Use")
-st.sidebar.write("""
-1. Select the date range for the analysis.
-2. Adjust the market drop percentage.
-3. Enter the tickers and their respective weights.
-4. Select the ticker for the drop scenario.
-5. Click on 'Run Analysis' to execute.
-""")
-
-# Sidebar inputs
-st.sidebar.header("Input Parameters")
-
-st.sidebar.subheader("Portfolio Allocation")
-portfolio_tickers = st.sidebar.text_area("Enter Tickers (comma-separated)", "^GSPC,MSFT,AAPL,GOOGL,ASML").split(',')
-portfolio_weights = st.sidebar.text_area("Enter Weights (comma-separated) (Must add to 1)", "0.1,0.3,0.3,0.2,0.1").split(',')
-portfolio_weights = [float(weight) for weight in portfolio_weights]
-
-drop_ticker = st.sidebar.text_input("Enter Drop Ticker", "^GSPC")
-market_drop_percentage = st.sidebar.slider("Market Drop Percentage", min_value=-0.1, max_value=0.0, step=0.01, value=-0.05)
-
-start_date = st.sidebar.date_input("Start Date", value=pd.to_datetime("2020-01-01"))
-end_date = st.sidebar.date_input("End Date", value=pd.to_datetime("2025-01-01"))
-num_simulations = st.sidebar.number_input("Number of Simulations", min_value=1000, max_value=100000, step=1000, value=50000)
-rolling_window = st.sidebar.number_input("Rolling Window", min_value=7, max_value=1000, step=10, value=250)
+# Sidebar: How to Use (closed by default)
+with st.sidebar.expander("How to Use", expanded=False):
+    st.write("""
+    1. Select the date range for the analysis.
+    2. Adjust the market drop percentage.
+    3. Enter the tickers and their respective weights.
+    4. Select the ticker for the drop scenario.
+    5. Click on 'Run Analysis' to execute.
+    """)
 
+# Sidebar: Ticker and Dates (open by default)
+with st.sidebar.expander("Ticker and Dates", expanded=True):
+    portfolio_tickers = st.text_area("Enter Tickers (comma-separated)", "^GSPC,MSFT,AAPL,GOOGL,ASML",
+                                     help="Enter the tickers for the assets in the portfolio, separated by commas.").split(',')
+    portfolio_weights = st.text_area("Enter Weights (comma-separated) (Must add to 1)", "0.1,0.3,0.3,0.2,0.1",
+                                     help="Enter the weights for each ticker, separated by commas. Make sure they sum to 1.").split(',')
+    portfolio_weights = [float(weight) for weight in portfolio_weights]
+
+    start_date = st.date_input("Start Date", value=pd.to_datetime("2020-01-01"),
+                               help="Select the start date for the analysis period.")
+    end_date = st.date_input("End Date", value=pd.to_datetime(pd.Timestamp.now().date() + pd.Timedelta(days=1)),
+                             help="Select the end date for the analysis period.")
+
+# Sidebar: Market Drop Settings (open by default)
+with st.sidebar.expander("Market Drop Settings", expanded=True):
+    drop_ticker = st.text_input("Enter Drop Ticker", "^GSPC",
+                                help="Enter the ticker of the asset that will experience a drop.")
+    market_drop_percentage = st.slider("Market Drop Percentage", min_value=-0.1, max_value=0.0, step=0.01, value=-0.05,
+                                       help="Set the percentage drop in the market for the scenario.")
+    num_simulations = st.number_input("Number of Simulations", min_value=1000, max_value=100000, step=1000, value=50000,
+                                      help="Set the number of simulations to run.")
+    rolling_window = st.number_input("Rolling Window", min_value=7, max_value=1000, step=10, value=250,
+                                     help="Set the rolling window size for tail dependence analysis.")
 
 if len(portfolio_tickers) != len(portfolio_weights):
     st.sidebar.error("The number of tickers must match the number of weights.")
 
-
 run_button = st.sidebar.button("Run Analysis")
 
 if run_button and len(portfolio_tickers) == len(portfolio_weights):
 
+    # Explanation of the Simulation and Copula Models
     st.markdown("## Simulating Market Drop Scenarios: Best, Worst, and Mean Cases")
-    #st.markdown("## Transforming Returns")
-    st.markdown("""
-    To prepare the returns for copula modeling, we transform them to a uniform distribution using quantile transformation. 
-    This step ensures that the data fits within the range required by the copula model.
-    """)
-    st.latex(r"""
-    u_i = \frac{\text{rank}(R_i)}{n + 1}
-    """)
+    st.markdown("This section explores how the portfolio performs under simulated market drop scenarios using copula models.")
 
-    #st.markdown("## Fitting the Copula Model")
-    st.markdown("""
-    Next, we fit a multivariate Student-t copula to the transformed data. The copula model captures the dependencies between the stock returns, 
-    enabling us to understand the joint behavior of the assets.
-    """)
-    st.latex(r"""
-    C_{\nu}(u_1, u_2, \ldots, u_d) = t_{\nu, \Sigma}(t_{\nu}^{-1}(u_1), t_{\nu}^{-1}(u_2), \ldots, t_{\nu}^{-1}(u_d))
-    """)
+    with st.expander("Methodology", expanded=False):
+        st.markdown("""
+        **Step 1: Transforming Returns**
+        - We transform the returns to a uniform distribution using quantile transformation. 
+        - This ensures that the data fits within the range required by the copula model.
 
-    #st.markdown("## Simulating Scenarios")
-    st.markdown("""
-    Using the fitted copula model, we simulate a large number of return scenarios. This simulation helps us explore potential future outcomes 
-    and assess the portfolio's risk under various market conditions.
-    """)
-
-    #st.markdown("## Market Drop Scenarios")
-    st.markdown("""
-    We identify scenarios where the specified ticker drops by the given percentage. By analyzing these scenarios, we can evaluate how the portfolio performs under stress.
-    """)
+        **Step 2: Fitting the Copula Model**
+        - A multivariate Student-t copula is fitted to the transformed data.
+        - The copula model captures the dependencies between the asset returns.
 
-    #st.markdown("## Portfolio Returns")
-    st.markdown("""
-    For each identified scenario, we calculate the portfolio returns. The portfolio return is a weighted sum of the individual stock returns.
-    """)
-    st.latex(r"""
-    R_p = \sum_{i=1}^{n} w_i R_i
-    """)
+        **Step 3: Simulating Scenarios**
+        - We simulate numerous return scenarios using the fitted copula model to assess the portfolio's risk under various market conditions.
 
-    #st.markdown("## Visualizing Results")
-    st.markdown("""
-    We visualize the simulated portfolio returns using histograms, cumulative distribution functions (CDF), and kernel density estimates (KDE). 
-    These visualizations help us understand the distribution and characteristics of potential returns.
-    """)
+        **Step 4: Portfolio Returns Calculation**
+        - For each identified scenario, we calculate the portfolio returns using a weighted sum of the individual asset returns.
 
-    #st.markdown("## Portfolio Price Trajectory")
-    st.markdown("""
-    Finally, we visualize the portfolio's price trajectory under the worst-case, best-case, and mean scenarios. 
-    This helps in understanding the potential impact of market drops on the portfolio value.
-    """)
-        
-    
-    
-    
+        **Step 5: Visualization**
+        - We visualize the simulated portfolio returns using histograms, CDFs, and KDEs to understand potential outcomes.
+        """)
 
     # Define the portfolio and allocation
     portfolio_allocation = dict(zip(portfolio_tickers, portfolio_weights))
@@ -138,7 +107,6 @@ if run_button and len(portfolio_tickers) == len(portfolio_weights):
     copula.fit(data_uniform.values)
 
     # Simulate scenarios
-    #num_simulations = 50000
     simulated_uniform = copula.random(num_simulations)
     simulated_returns = pd.DataFrame(index=range(num_simulations), columns=data_uniform.columns)
 
@@ -257,25 +225,23 @@ if run_button and len(portfolio_tickers) == len(portfolio_weights):
 
         st.plotly_chart(fig_price)
 
-    # Tail Dependence Analysis
     # Tail Dependence Analysis
     st.markdown("## Tail Dependence Analysis")
     st.markdown("""
     Tail dependence measures the likelihood of extreme returns occurring simultaneously across different stocks in the portfolio. 
-    It is a critical aspect of understanding how assets behave in extreme market conditions.
-
-    We use the Clayton copula to model the tail dependence. The parameter \\(\theta\\) of the Clayton copula is related to the tail dependence by:
-    """)
-    st.latex(r"""
-    \lambda_{L} = 2^{1/\theta} - 1
-    """)
-    st.markdown("""
-    Where:
-    - λ1 is the lower tail dependence.
-    - θ is the parameter of the Clayton copula.
-
-    A higher λ1 value indicates a stronger relationship in the tails, meaning that extreme losses in one stock are more likely to coincide with extreme losses in another.
+    We use the Clayton copula to model the tail dependence. The parameter θ of the Clayton copula is related to the tail dependence by:
     """)
+    
+    with st.expander("Tail Dependence Methodology", expanded=False):
+        st.latex(r"""
+        \lambda_{L} = 2^{1/\theta} - 1
+        """)
+        st.markdown("""
+        Where:
+        - λ1 is the lower tail dependence.
+        - θ is the parameter of the Clayton copula.
+        A higher λ1 value indicates a stronger relationship in the tails, meaning that extreme losses in one stock are more likely to coincide with extreme losses in another.
+        """)
 
     def to_uniform(column):
         n = len(column)
@@ -336,11 +302,10 @@ if run_button and len(portfolio_tickers) == len(portfolio_weights):
     """)
 
     # Rolling window analysis
-    window_size = rolling_window #250
     tail_parameters = []
 
-    for start in range(0, len(uniform_data) - window_size):
-        window_data = uniform_data.iloc[start:start + window_size]
+    for start in range(0, len(uniform_data) - rolling_window):
+        window_data = uniform_data.iloc[start:start + rolling_window]
 
         copula = Clayton()
         copula.fit(window_data.values)
@@ -350,7 +315,7 @@ if run_button and len(portfolio_tickers) == len(portfolio_weights):
 
     # Tail Dependence Over Time
     fig1 = go.Figure()
-    fig1.add_trace(go.Scatter(x=returns.index[window_size:], y=tail_parameters, mode='lines', name='Tail Dependence Parameter'))
+    fig1.add_trace(go.Scatter(x=returns.index[rolling_window:], y=tail_parameters, mode='lines', name='Tail Dependence Parameter'))
     fig1.update_layout(
         title="Tail Dependence Over Time",
         xaxis_title="Date",
@@ -359,11 +324,11 @@ if run_button and len(portfolio_tickers) == len(portfolio_weights):
 
     st.plotly_chart(fig1)
 
-
+# Hide the Streamlit style elements
 hide_streamlit_style = """
 <style>
 #MainMenu {visibility: hidden;}
 footer {visibility: hidden;}
 </style>
 """
-st.markdown(hide_streamlit_style, unsafe_allow_html=True) 
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)