Update app.py

app.py

@@ -21,51 +21,44 @@ 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 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.
+    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.
     ##### **What You Can Do:**
-    - **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.
+    - **Adjust Parameters**: Tweak the base window, alpha, beta, and signal threshold.
+    - **Visual Feedback**: View buy/sell signals and the equity curve on a chart.
     ''')
 
-# Sidebar: "How to Use" expander (closed by default)
 with st.sidebar.expander("How to Use", expanded=False):
     st.write("""
-    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.
+    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.
     """)
 
 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.")
 
-# Function to download data
 @st.cache_data
 def get_data(ticker, start, end):
     data = yf.download(ticker, start=start, end=end)
     return data['Close']
 
-# Exponential Moving Average based OU parameters with adjustment
 def OU_parameters_ema(data, window):
-    # Ensure window is a scalar integer
-    window = int(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())
@@ -74,7 +67,6 @@ 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 = []
@@ -82,16 +74,23 @@ def trading_strategy(data, base_window=60, base_alpha=1.0, beta=0.1, trend_windo
     positions = []
     trend = data.rolling(window=trend_window).mean()
 
+    # For indices where the trend is not fully defined, append NaNs and no position.
     for i in range(len(data)):
-        # Cast window to integer to avoid ambiguous Series error
+        if i < trend_window - 1:
+            buy_signals.append(np.nan)
+            sell_signals.append(np.nan)
+            positions.append(0)
+            continue
+
         window = int(windows.iloc[i])
         mu, sigma = OU_parameters_ema(data[:i+1], window=window)
-        alpha = base_alpha + beta * sigma.iloc[-1]
-        price = data.iloc[i]
-        mu_value = mu.iloc[-1]
-        sigma_value = sigma.iloc[-1]
-        trend_value = trend.iloc[i]
-
+        alpha = base_alpha + beta * float(sigma.iloc[-1])
+        # Convert each to float to ensure scalar comparison
+        price = float(data.iloc[i])
+        mu_value = float(mu.iloc[-1])
+        sigma_value = float(sigma.iloc[-1])
+        trend_value = float(trend.iloc[i])
+        
         if price < mu_value - (alpha + signal_threshold) * sigma_value and price < trend_value:
             buy_signals.append(price)
             sell_signals.append(np.nan)
@@ -107,14 +106,12 @@ def trading_strategy(data, base_window=60, base_alpha=1.0, beta=0.1, trend_windo
 
     return buy_signals, sell_signals, positions, trend
 
-# Function to calculate performance metric and equity curve
 def calculate_performance(data, positions):
     returns = np.diff(data) / data[:-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  # starting equity 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
@@ -141,34 +138,25 @@ def grid_search(data, param_grid):
             best_positions = positions
             best_trend = trend
 
-    progress_bar.empty()  # Remove the progress bar when done
+    progress_bar.empty()
     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)
-
-    # Define the parameter grid
     param_grid = {
         'base_window': [30, 50, 70, 90],
         'base_alpha': [0.5, 1.0, 1.5],
         'beta': [0.05, 0.1, 0.15],
         'trend_window': [100, 200, 300]
     }
-
-    # Perform grid search to find the best parameters
     best_params, best_performance, best_positions, best_trend = grid_search(data, param_grid)
-
-    # Cache the results for faster updates when adjusting parameters
     st.session_state['data'] = data
     st.session_state['best_params'] = best_params
     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],
@@ -178,41 +166,19 @@ 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:
     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."
-    )
-
-    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."
-    )
-
-    # Apply the trading strategy with adjusted parameters
     buy_signals, sell_signals, positions, trend = trading_strategy(
         st.session_state['data'],
         base_window=base_window,
@@ -221,11 +187,8 @@ if 'best_params' in st.session_state:
         trend_window=trend_window,
         signal_threshold=signal_threshold
     )
-
-    # Calculate the updated equity curve
     equity_curve = calculate_performance(st.session_state['data'], positions)
 
-    # Plotting
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True,
                         subplot_titles=("Price and Signals", "Equity Curve"),
                         vertical_spacing=0.1)