Update app.py

app.py

@@ -21,45 +21,51 @@ This tool backtests and optimizes a mean-reversion trading strategy. The idea be
 
 with st.expander("How the Strategy Works:", expanded=False):
     st.markdown('''
-    1. **Dynamic Window Sizes**: The strategy changes the window size it uses for calculating moving averages based on market volatility.
-    2. **Exponential Moving Average (EMA)**: Uses an EMA that gives more weight to recent prices.
-    3. **Trend Filter**: Ensures trades align with the overall trend.
-    4. **Buy/Sell Signals**:
-        - **Buy Signal**: Generated when the price is below the EMA (with an adaptive threshold) and below the trend.
-        - **Sell Signal**: Generated when the price is above the EMA and above the trend.
-    5. **Grid Search Optimization**: Tests different parameter combinations to find the best performance.
+    1. **Dynamic Window Sizes**: The strategy changes the window size it uses for calculating moving averages based on how volatile the market is. When volatility is high, it uses shorter windows, making it more responsive to rapid price movements. When volatility is low, it uses longer windows, which smooths out the data and reduces noise.
+    2. **Exponential Moving Average (EMA)**: The strategy uses an EMA to track the average price. The EMA gives more weight to recent prices, so it reacts more quickly to changes compared to a simple moving average. This helps capture shifts in the market earlier.
+    3. **Trend Filter**: A trend filter is added to make sure the strategy only takes trades in the direction of the overall market trend. This helps avoid taking trades that go against the bigger picture, which can lead to bad signals.
+    4. **Buy/Sell Signals**: 
+        - **Buy Signal**: A buy signal is generated when the price drops below the EMA and the trend shows an uptrend. This suggests that the price is likely to bounce back.
+        - **Sell Signal**: A sell signal occurs when the price goes above the EMA and the trend is showing a downtrend, indicating the price might fall soon.
+    5. **Grid Search Optimization**: The app runs a grid search to test different combinations of parameters (like window sizes and thresholds) to find the ones that work best for the selected data. This helps maximize the strategy's performance.
     ##### **What You Can Do:**
-    - **Adjust Parameters**: Tweak the base window, alpha, beta, and signal threshold.
-    - **Visual Feedback**: View buy/sell signals and the equity curve on a chart.
+    - **Adjust Parameters**: After running the initial optimization, you can tweak the base window size, alpha, beta, and signal threshold to see how the strategy’s performance changes.
+    - **Signal Threshold**: This controls how strict the buy/sell signals are. A lower threshold will give you more signals, while a higher threshold will be more selective.
+    - **Visual Feedback**: The app shows you the strategy’s performance visually, plotting buy/sell signals on a price chart and showing an equity curve so you can see how well the strategy performs over time.
     ''')
 
+# Sidebar: "How to Use" expander (closed by default)
 with st.sidebar.expander("How to Use", expanded=False):
     st.write("""
-    1. **Select Ticker**: Choose an asset symbol (e.g., AAPL, TSLA) and a date range.
-    2. **Run Strategy**: Click "Run Strategy" to optimize parameters and run the backtest.
-    3. **Adjust Parameters**: Use sliders to fine-tune the moving average window, beta, and signal threshold.
-    4. **Visualize**: The app displays buy/sell signals and the equity curve.
+    1. **Select Ticker**: Choose the asset ticker symbol (e.g., AAPL, TSLA) and date range for historical data.
+    2. **Run Strategy**: Click "Run Strategy" to optimize the parameters and run the backtest.
+    3. **Adjust Parameters**: Use the sliders to fine-tune the moving average windows, beta, and signal threshold to see how the strategy performs.
+    4. **Visualize**: The app displays buy/sell signals, the trend line, and the equity curve.
     """)
 
 st.sidebar.title("Input Parameters")
 
+# Sidebar: Select Ticker and Date Range
 with st.sidebar.expander("Asset Settings", expanded=True):
     ticker = st.text_input("Asset Symbol", value="AAPL", help="Ticker symbol or Cryptocurrency Pair (e.g., AAPL, BTC-USD)")
     start_date = st.date_input("Start Date", value=pd.to_datetime("2020-01-01"), help="Select the start date for historical data.")
     end_date = st.date_input("End Date", value=datetime.today() + pd.DateOffset(1), help="Select the end date for historical data.")
 
-# Modified get_data: squeeze the 'Close' column to ensure a 1D Series
+# Function to download data
 @st.cache_data
 def get_data(ticker, start, end):
     data = yf.download(ticker, start=start, end=end)
+    # Squeeze the 'Close' column to ensure a 1D Series (fixes new yfinance behavior)
     return data['Close'].squeeze()
 
+# Exponential Moving Average based OU parameters
 def OU_parameters_ema(data, window):
     window = int(window)  # ensure window is scalar
     mu = data.ewm(span=window).mean()
     sigma = data.ewm(span=window).std()
     return mu, sigma
 
+# Dynamic window size based on volatility
 def dynamic_window(data, base_window=60, volatility_window=20):
     volatility = data.rolling(window=volatility_window).std()
     adjusted_window = base_window / (volatility / volatility.mean())
@@ -68,6 +74,7 @@ def dynamic_window(data, base_window=60, volatility_window=20):
     adjusted_window = adjusted_window.round().astype(int).clip(lower=20, upper=120)
     return adjusted_window
 
+# Trading strategy with trend filter and adjustable parameters
 def trading_strategy(data, base_window=60, base_alpha=1.0, beta=0.1, trend_window=200, signal_threshold=0):
     windows = dynamic_window(data, base_window=base_window)
     buy_signals = []
@@ -76,7 +83,7 @@ def trading_strategy(data, base_window=60, base_alpha=1.0, beta=0.1, trend_windo
     trend = data.rolling(window=trend_window).mean()
 
     for i in range(len(data)):
-        # For early indices where the trend is not fully defined, skip trading logic.
+        # Use trading only if trend is defined; otherwise, append NaN and no position
         if i < trend_window - 1:
             buy_signals.append(np.nan)
             sell_signals.append(np.nan)
@@ -86,7 +93,7 @@ def trading_strategy(data, base_window=60, base_alpha=1.0, beta=0.1, trend_windo
         window = int(windows.iloc[i])
         mu, sigma = OU_parameters_ema(data[:i+1], window=window)
         alpha = base_alpha + beta * float(sigma.iloc[-1])
-        # Force each value to be a float to ensure scalar comparisons:
+        # Convert values to floats to ensure scalar comparisons
         price = float(data.iloc[i])
         mu_value = float(mu.iloc[-1])
         sigma_value = float(sigma.iloc[-1])
@@ -107,14 +114,16 @@ def trading_strategy(data, base_window=60, base_alpha=1.0, beta=0.1, trend_windo
 
     return buy_signals, sell_signals, positions, trend
 
-# Modified calculate_performance: explicitly convert the price Series to a 1D NumPy array.
+# Function to calculate performance metric and equity curve
 def calculate_performance(data, positions):
-    data_np = data.to_numpy()  # ensure 1D array
+    # Convert data to a 1D NumPy array to avoid shape issues
+    data_np = data.to_numpy().flatten()
     returns = np.diff(data_np) / data_np[:-1]
     strategy_returns = np.array(positions[:-1]) * returns
-    equity_curve = np.cumprod(1 + strategy_returns) * 100  # starting equity of 100
+    equity_curve = np.cumprod(1 + strategy_returns) * 100  # Start with an initial value of 100
     return equity_curve
 
+# Grid search for best parameters with progress
 def grid_search(data, param_grid):
     best_params = None
     best_performance = -np.inf
@@ -130,9 +139,7 @@ def grid_search(data, param_grid):
         iteration += 1
         progress_bar.progress(iteration / total_iterations)
 
-        buy_signals, sell_signals, positions, trend = trading_strategy(
-            data, base_window=base_window, base_alpha=base_alpha, beta=beta, trend_window=trend_window
-        )
+        buy_signals, sell_signals, positions, trend = trading_strategy(data, base_window=base_window, base_alpha=base_alpha, beta=beta, trend_window=trend_window)
         equity_curve = calculate_performance(data, np.array(positions))
         performance = equity_curve[-1]
         if performance > best_performance:
@@ -141,12 +148,14 @@ def grid_search(data, param_grid):
             best_positions = positions
             best_trend = trend
 
-    progress_bar.empty()
+    progress_bar.empty()  # Remove the progress bar when done
     return best_params, best_performance, best_positions, best_trend
 
+# Run Button in the Sidebar
 run_button = st.sidebar.button("Run Strategy")
 
 if run_button:
+    # Get historical data
     data = get_data(ticker, start_date, end_date)
     param_grid = {
         'base_window': [30, 50, 70, 90],
@@ -160,6 +169,7 @@ if run_button:
     st.session_state['best_positions'] = best_positions
     st.session_state['best_trend'] = best_trend
 
+    # Display best parameters in JSON format
     st.json({
         "Best Parameters": {
             "Base Window": best_params[0],
@@ -169,19 +179,42 @@ if run_button:
         }
     })
 
+# If the session state has the optimized data, allow updating the signal threshold and other parameters without re-running the optimization
 if 'best_params' in st.session_state:
+    # Sliders to adjust parameters and signal threshold
     st.sidebar.subheader("Adjust Parameters")
-    base_window = st.sidebar.slider("Base Window", 20, 120, st.session_state['best_params'][0],
-                                    help="Adjust the base window size.")
-    base_alpha = st.sidebar.slider("Base Alpha", 0.1, 2.0, st.session_state['best_params'][1], 0.1,
-                                   help="Adjust the base alpha value.")
-    beta = st.sidebar.slider("Beta", 0.01, 0.3, st.session_state['best_params'][2], 0.01,
-                             help="Adjust the beta value.")
-    trend_window = st.sidebar.slider("Trend Window", 50, 400, st.session_state['best_params'][3],
-                                     help="Adjust the trend window size.")
-    signal_threshold = st.sidebar.slider("Signal Threshold", -0.2, 0.2, 0.0, 0.01,
-                                         help="Adjust the signal threshold.")
 
+    base_window = st.sidebar.slider(
+        "Base Window",
+        20, 120, st.session_state['best_params'][0],
+        help="Adjust the base window size. A larger window smooths the data more but reacts slower to price changes."
+    )
+
+    base_alpha = st.sidebar.slider(
+        "Base Alpha",
+        0.1, 2.0, st.session_state['best_params'][1], 0.1,
+        help="Adjust the base alpha value. A higher alpha increases the sensitivity to deviations from the mean."
+    )
+
+    beta = st.sidebar.slider(
+        "Beta",
+        0.01, 0.3, st.session_state['best_params'][2], 0.01,
+        help="Adjust the beta value, which controls how much volatility affects the adaptive threshold."
+    )
+
+    trend_window = st.sidebar.slider(
+        "Trend Window",
+        50, 400, st.session_state['best_params'][3],
+        help="Adjust the trend window size. A larger trend window smooths long-term trends but reacts slower to trend changes."
+    )
+
+    signal_threshold = st.sidebar.slider(
+        "Signal Threshold",
+        -0.2, 0.2, 0.0, 0.01,
+        help="Adjust the signal threshold: Lower values are more lenient (generate more signals), while higher values are more restrictive."
+    )
+
+    # Apply the trading strategy with the adjusted parameters
     buy_signals, sell_signals, positions, trend = trading_strategy(
         st.session_state['data'],
         base_window=base_window,
@@ -192,16 +225,21 @@ if 'best_params' in st.session_state:
     )
     equity_curve = calculate_performance(st.session_state['data'], positions)
 
+    # Plotting with adjustments for easier comparison of x-axis
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True,
                         subplot_titles=("Price and Signals", "Equity Curve"),
                         vertical_spacing=0.1)
 
+    # Price and signal plot
     fig.add_trace(go.Scatter(x=st.session_state['data'].index, y=st.session_state['data'], mode='lines', name='Price'), row=1, col=1)
     fig.add_trace(go.Scatter(x=st.session_state['data'].index, y=trend, mode='lines', name=f"Trend Filter (SMA {trend_window})", line=dict(dash='dash')), row=1, col=1)
     fig.add_trace(go.Scatter(x=st.session_state['data'].index, y=buy_signals, mode='markers', name='Buy Signal', marker=dict(color='green', symbol='triangle-up', size=10)), row=1, col=1)
     fig.add_trace(go.Scatter(x=st.session_state['data'].index, y=sell_signals, mode='markers', name='Sell Signal', marker=dict(color='red', symbol='triangle-down', size=10)), row=1, col=1)
+
+    # Equity Curve Plot
     fig.add_trace(go.Scatter(x=st.session_state['data'].index[1:], y=equity_curve, mode='lines', name='Equity Curve'), row=2, col=1)
 
+    # Adjust layout for better clarity
     fig.update_layout(
         height=800,
         title=f'{ticker} Optimized Mean-Reversion Trading Strategy',