Update app.py

app.py

@@ -218,6 +218,45 @@ def create_features(data: pd.DataFrame) -> pd.DataFrame:
         df['Volume_Ratio'] = 1.0
         df['OBV_Signal']   = 0.0
 
+    # ── FIX 4: Direction Composite Signal (boosts directional accuracy) ─────
+    # Encodes consensus of multiple indicators into a single direction score.
+    # Positive → bullish bias, Negative → bearish bias.
+    direction_score = pd.Series(0.0, index=df.index)
+
+    # RSI signal: oversold=bullish, overbought=bearish
+    if 'RSI_14' in df.columns:
+        direction_score += (50 - df['RSI_14']) / 50   # +1 at RSI=0, -1 at RSI=100
+
+    # MACD histogram direction
+    if 'MACD_Hist' in df.columns:
+        direction_score += np.sign(df['MACD_Hist'])
+
+    # Stoch cross: K above D = bullish
+    if 'Stoch_Cross' in df.columns:
+        direction_score += np.sign(df['Stoch_Cross'])
+
+    # Price vs SMA21
+    if 'Dist_SMA21' in df.columns:
+        direction_score += np.sign(df['Dist_SMA21'])
+
+    # EMA cross
+    if 'EMA3_EMA21_Cross' in df.columns:
+        direction_score += np.sign(df['EMA3_EMA21_Cross'])
+
+    # ROC momentum
+    if 'ROC_5' in df.columns:
+        direction_score += np.sign(df['ROC_5'])
+
+    df['Direction_Score'] = direction_score / 6.0   # normalise to [-1, +1]
+
+    # Momentum consistency: are recent returns all same sign?
+    if 'LagRet_1' in df.columns and 'LagRet_2' in df.columns and 'LagRet_3' in df.columns:
+        df['Momentum_Consistency'] = (
+            np.sign(df['LagRet_1']) +
+            np.sign(df['LagRet_2']) +
+            np.sign(df['LagRet_3'])
+        ) / 3.0
+
     return df.dropna()
 
 
@@ -258,6 +297,8 @@ FEATURE_COLS = [
     'Range_Pct5', 'Range_Pct20',
     # Volume
     'Volume_Ratio', 'OBV_Signal',
+    # Direction composite (FIX 4)
+    'Direction_Score', 'Momentum_Consistency',
 ]
 
 
@@ -294,25 +335,24 @@ def select_best_alpha(X_tr, y_tr) -> float:
 def train_ridge(df: pd.DataFrame, horizon: int = 1):
     """
     Trains the premium Ridge model.
-    Target: price delta after `horizon` days.
+    Target: log-return over `horizon` days (direction-aware).
     Returns pipeline, test predictions (absolute), y_test (absolute), avail_cols.
     """
     avail = [c for c in FEATURE_COLS if c in df.columns]
     X     = df[avail].values
     close = df['Close'].values
 
-    # Build delta target aligned to horizon
-    y_delta        = np.zeros(len(close) - horizon)
-    for h in range(1, horizon + 1):
-        y_delta += close[h:len(close) - horizon + h] - close[:len(close) - horizon]
-    y_delta /= horizon   # average delta per day (smoother target)
+    # --- FIX 1: Use log-return as target (direction-aware, scale-invariant) ---
+    # log-return = log(close[t+horizon] / close[t])
+    # This directly encodes direction: positive = UP, negative = DOWN
+    y_logret = np.log(close[horizon:] / close[:len(close) - horizon])
 
-    X = X[:len(y_delta)]
-    close_aligned = close[:len(y_delta)]
+    X = X[:len(y_logret)]
+    close_aligned = close[:len(y_logret)]
 
     split = -15   # 15-day test window for robust backtest
     X_train, X_test       = X[:split],           X[split:]
-    y_train, y_delta_test = y_delta[:split],      y_delta[split:]
+    y_train, y_logret_test = y_logret[:split],   y_logret[split:]
     close_test            = close_aligned[split:]
 
     # Find best alpha on training data only
@@ -322,10 +362,10 @@ def train_ridge(df: pd.DataFrame, horizon: int = 1):
     pipe = build_ridge_pipeline(best_alpha)
     pipe.fit(X_train, y_train)
 
-    # Test predictions → absolute price
-    delta_hat  = pipe.predict(X_test)
-    pred_abs   = close_test + delta_hat
-    y_test_abs = close_test + y_delta_test
+    # Test predictions → convert log-return back to absolute price
+    logret_hat = pipe.predict(X_test)
+    pred_abs   = close_test * np.exp(logret_hat)
+    y_test_abs = close_test * np.exp(y_logret_test)
 
     mae  = mean_absolute_error(y_test_abs, pred_abs)
 
@@ -334,11 +374,12 @@ def train_ridge(df: pd.DataFrame, horizon: int = 1):
 
 def predict_next_ridge(pipe, df: pd.DataFrame, avail: list,
                        horizon: int = 1) -> float:
-    """Predict absolute close price horizon days ahead."""
+    """Predict absolute close price horizon days ahead using log-return."""
     cp = float(df['Close'].iloc[-1])
     x  = df[avail].iloc[-1].values.reshape(1, -1)
-    delta = float(pipe.predict(x)[0])
-    return cp + delta * horizon
+    logret = float(pipe.predict(x)[0])
+    # Scale logret by horizon for multi-day forecasts
+    return cp * np.exp(logret * horizon)
 
 
 # ══════════════════════════════════════════════════════════════════════════════
@@ -636,9 +677,19 @@ def predict_eurusd(horizon: int = 1):
 
         # 7. Backtest metrics
         rmse = float(np.sqrt(np.mean((test_pred_abs - y_test_abs) ** 2)))
-        hit  = float(np.mean(
-            np.sign(np.diff(test_pred_abs)) == np.sign(np.diff(y_test_abs))
-        )) * 100
+        # FIX 3: Correct directional accuracy — compare pred vs entry price
+        close_vals = df['Close'].values
+        n_test = len(test_pred_abs)
+        entry_prices = close_vals[len(close_vals) - n_test - horizon :
+                                  len(close_vals) - horizon]
+        if len(entry_prices) == n_test:
+            pred_dirs   = np.sign(test_pred_abs - entry_prices)
+            actual_dirs = np.sign(y_test_abs    - entry_prices)
+            hit = float(np.mean(pred_dirs == actual_dirs)) * 100
+        else:
+            hit = float(np.mean(
+                np.sign(np.diff(test_pred_abs)) == np.sign(np.diff(y_test_abs))
+            )) * 100
 
         # 8. Indicators
         rsi  = float(df['RSI_14'].iloc[-1])