Change weights calculation

Author: MDUYN

investing_algorithm_framework/app/analysis/ranking.py

@@ -1,58 +1,178 @@
-from investing_algorithm_framework.domain import Backtest
+default_weights = {
+    # Profitability
+    "total_net_gain": 3.0,
+    "total_net_loss": 0.0,
+    "total_return": 0.0,
+    "avg_return_per_trade": 0.0,
 
-defaults_ranking_weights = {
-    "total_net_gain": 2.0,
+    # Risk-adjusted returns
     "sharpe_ratio": 1.0,
     "sortino_ratio": 1.0,
-    "win_rate": 1.0,
     "profit_factor": 1.0,
-    "max_drawdown": -1.0,  # negative weight to penalize high drawdown
-    "max_drawdown_duration": -0.5,  # penalize long drawdown periods
-    "number_of_trades": 0.5,
+
+    # Risk
+    "max_drawdown": -2.0,
+    "max_drawdown_duration": -0.5,
+
+    # Trading activity
+    "number_of_trades": 2.0,
+    "win_rate": 3.0,
+
+    # Exposure
     "exposure_factor": 0.5,
+    "exposure_ratio": 0.0,
+    "exposure_time": 0.0,
 }
 
 
-def compute_score(metrics: dict, weights: dict) -> float:
+def normalize(value, min_val, max_val):
+    """
+    Normalize a value to a range [0, 1].
+
+    Args:
+        value (float): The value to normalize.
+        min_val (float): The minimum value of the range.
+        max_val (float): The maximum value of the range.
+
+    Returns:
+        float: The normalized value.
+    """
+    if max_val == min_val:
+        return 0
+    return (value - min_val) / (max_val - min_val)
+
+
+def compute_score(metrics, weights, ranges):
+    """
+    Compute a weighted score for the given metrics.
+
+    Args:
+        metrics: The metrics to evaluate.
+        weights: The weights to apply to each metric.
+        ranges: The min/max ranges for each metric.
+
+    Returns:
+        float: The computed score.
+    """
     score = 0
     for key, weight in weights.items():
 
-        # Metrics are attributes to the backtest
         if not hasattr(metrics, key):
             continue
-
-        # Get the value of the metric
         value = getattr(metrics, key)
 
-        try:
-            score += weight * value
-        except TypeError:
-            continue  # skip if value is not a number
+        if key in ranges:
+            value = normalize(value, ranges[key][0], ranges[key][1])
+        score += weight * value
     return score
 
 
-def rank_results(
-    backtests: list[Backtest], weights=defaults_ranking_weights
-) -> list[Backtest]:
+def create_weights(
+    focus: str = "balanced",
+    gain: float = 3.0,
+    win_rate: float = 3.0,
+    trades: float = 2.0,
+    custom_weights: dict | None = None,
+) -> dict:
+    """
+    Utility to generate weights dicts for ranking backtests.
+
+    This function does not assign weights to every possible performance
+    metric. Instead, it focuses on a curated subset of commonly relevant
+    ones (profitability, win rate, trade frequency, and risk-adjusted returns).
+    The rationale is to avoid overfitting ranking logic to noisy or redundant
+    statistics (e.g., monthly return breakdowns, best/worst trade), while
+    keeping the weighting system simple and interpretable.
+    Users who need fine-grained control can pass `custom_weights` to fully
+    override defaults.
+
+    Args:
+        focus (str): One of [
+            "balanced", "profit", "frequency", "risk_adjusted"
+        ].
+        gain (float): Weight for total_net_gain (default only).
+        win_rate (float): Weight for win_rate (default only).
+        trades (float): Weight for number_of_trades (default only).
+        custom_weights (dict): Full override for weights (all metrics).
+                               If provided, it takes precedence over presets.
+
+    Returns:
+        dict: A dictionary of weights for ranking backtests.
     """
-    Rank backtests based on their metrics and the provided weights.
 
-    The default weights are defined in `defaults_ranking_weights`.
-    Please note that the weights should be adjusted based on the
-    specific analysis needs. You can modify the `weights` parameter
-    to include or exclude metrics as needed and reuse
-    the `defaults_ranking_weights` as a starting point.
+    # default / balanced
+    base = {
+        "total_net_gain": gain,
+        "win_rate": win_rate,
+        "number_of_trades": trades,
+        "sharpe_ratio": 1.0,
+        "sortino_ratio": 1.0,
+        "profit_factor": 1.0,
+        "max_drawdown": -2.0,
+        "max_drawdown_duration": -0.5,
+        "total_net_loss": 0.0,
+        "total_return": 0.0,
+        "avg_return_per_trade": 0.0,
+        "exposure_factor": 0.5,
+        "exposure_ratio": 0.0,
+        "exposure_time": 0.0,
+    }
 
+    # apply presets
+    if focus == "profit":
+        base.update({
+            "total_net_gain": 5.0,
+            "win_rate": 2.0,
+            "number_of_trades": 1.0,
+        })
+    elif focus == "frequency":
+        base.update({
+            "number_of_trades": 4.0,
+            "win_rate": 2.0,
+            "total_net_gain": 2.0,
+        })
+    elif focus == "risk_adjusted":
+        base.update({
+            "sharpe_ratio": 3.0,
+            "sortino_ratio": 3.0,
+            "max_drawdown": -3.0,
+        })
+
+    # if full custom dict is given → override everything
+    if custom_weights is not None:
+        base = {**base, **custom_weights}
+
+    return base
+
+
+def rank_results(backtests, focus=None, weights=None):
+    """
+    Rank backtest results based on specified focus and weights.
     Args:
-        backtests (list[Backtest]): List of Backtest objects to rank.
-        weights (dict): Weights for each metric to compute the score.
+        backtests (list): List of backtest results to rank.
+        focus (str, optional): Focus for ranking. If None,
+            uses default weights. Options: "balanced", "profit",
+            "frequency", "risk_adjusted".
+        weights (dict, optional): Custom weights for ranking metrics.
+            If None, uses default weights based on focus.
 
     Returns:
-        list[Backtest]: List of Backtest objects sorted by
-            their computed score.
+        list: Sorted list of backtests based on computed scores.
     """
+
+    if weights is None:
+        weights = create_weights(focus=focus)
+
+    # First compute metric ranges for normalization
+    ranges = {}
+    for key in weights:
+        values = [getattr(bt.backtest_metrics, key, None) for bt in backtests]
+        values = [v for v in values if isinstance(v, (int, float))]
+        if values:
+            ranges[key] = (min(values), max(values))
+
     return sorted(
         backtests,
-        key=lambda bt: compute_score(bt.backtest_metrics, weights),
+        key=lambda bt: compute_score(bt.backtest_metrics, weights, ranges),
         reverse=True
     )

investing_algorithm_framework/services/metrics/win_rate.py

@@ -42,15 +42,15 @@ def get_win_rate(trades: List[Trade]) -> float:
     The percentage of trades that are profitable.
 
     Formula:
-        Win Rate = (Number of Profitable Trades / Total Number of Trades) * 100
+        Win Rate = Number of Profitable Trades / Total Number of Trades
 
     Example: If 60 out of 100 trades are profitable, the win rate is 60%.
 
     Args:
         trades (List[Trade]): List of trades from the backtest report.
 
     Returns:
-        float: The win rate as a percentage (e.g., 75.0 for 75% win rate).
+        float: The win rate as a percentage (e.g., o.75 for 75% win rate).
     """
     trades = [
         trade for trade in trades if TradeStatus.CLOSED.equals(trade.status)
@@ -61,7 +61,7 @@ def get_win_rate(trades: List[Trade]) -> float:
     if total_trades == 0:
         return 0.0
 
-    return (positive_trades / total_trades) * 100.0
+    return positive_trades / total_trades
 
 
 def get_win_loss_ratio(trades: List[Trade]) -> float: