Move hyperopt-loss functions to their own package

freqtrade/optimize/hyperopt_loss/hyperopt_loss_calmar.py

@@ -0,0 +1,63 @@
+"""
+CalmarHyperOptLoss
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+from datetime import datetime
+from math import sqrt as msqrt
+from typing import Any, Dict
+
+from pandas import DataFrame
+
+from freqtrade.data.btanalysis import calculate_max_drawdown
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+class CalmarHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation uses the Calmar Ratio calculation.
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(
+        results: DataFrame,
+        trade_count: int,
+        min_date: datetime,
+        max_date: datetime,
+        config: Dict,
+        processed: Dict[str, DataFrame],
+        backtest_stats: Dict[str, Any],
+        *args,
+        **kwargs
+    ) -> float:
+        """
+        Objective function, returns smaller number for more optimal results.
+
+        Uses Calmar Ratio calculation.
+        """
+        total_profit = backtest_stats["profit_total"]
+        days_period = (max_date - min_date).days
+
+        # adding slippage of 0.1% per trade
+        total_profit = total_profit - 0.0005
+        expected_returns_mean = total_profit.sum() / days_period * 100
+
+        # calculate max drawdown
+        try:
+            _, _, _, _, _, max_drawdown = calculate_max_drawdown(
+                results, value_col="profit_abs"
+            )
+        except ValueError:
+            max_drawdown = 0
+
+        if max_drawdown != 0:
+            calmar_ratio = expected_returns_mean / max_drawdown * msqrt(365)
+        else:
+            # Define high (negative) calmar ratio to be clear that this is NOT optimal.
+            calmar_ratio = -20.0
+
+        # print(expected_returns_mean, max_drawdown, calmar_ratio)
+        return -calmar_ratio

freqtrade/optimize/hyperopt_loss/hyperopt_loss_max_drawdown.py

@@ -0,0 +1,41 @@
+"""
+MaxDrawDownHyperOptLoss
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+from datetime import datetime
+
+from pandas import DataFrame
+
+from freqtrade.data.btanalysis import calculate_max_drawdown
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+class MaxDrawDownHyperOptLoss(IHyperOptLoss):
+
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation optimizes for max draw down and profit
+    Less max drawdown more profit -> Lower return value
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               min_date: datetime, max_date: datetime,
+                               *args, **kwargs) -> float:
+
+        """
+        Objective function.
+
+        Uses profit ratio weighted max_drawdown when drawdown is available.
+        Otherwise directly optimizes profit ratio.
+        """
+        total_profit = results['profit_abs'].sum()
+        try:
+            max_drawdown = calculate_max_drawdown(results, value_col='profit_abs')
+        except ValueError:
+            # No losing trade, therefore no drawdown.
+            return -total_profit
+        return -total_profit / max_drawdown[0]

freqtrade/optimize/hyperopt_loss/hyperopt_loss_onlyprofit.py

@@ -0,0 +1,26 @@
+"""
+OnlyProfitHyperOptLoss
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+from pandas import DataFrame
+
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+class OnlyProfitHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation takes only absolute profit into account, not looking at any other indicator.
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for better results.
+        """
+        total_profit = results['profit_abs'].sum()
+        return -1 * total_profit

freqtrade/optimize/hyperopt_loss/hyperopt_loss_profit_drawdown.py

@@ -0,0 +1,30 @@
+"""
+ProfitDrawDownHyperOptLoss
+
+This module defines the alternative HyperOptLoss class based on Profit &
+Drawdown objective which can be used for Hyperoptimization.
+
+Possible to change `DRAWDOWN_MULT` to penalize drawdown objective for
+individual needs.
+"""
+from pandas import DataFrame
+
+from freqtrade.data.btanalysis import calculate_max_drawdown
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+# higher numbers penalize drawdowns more severely
+DRAWDOWN_MULT = 0.075
+
+
+class ProfitDrawDownHyperOptLoss(IHyperOptLoss):
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int, *args, **kwargs) -> float:
+        total_profit = results["profit_abs"].sum()
+
+        try:
+            max_drawdown_abs = calculate_max_drawdown(results, value_col="profit_abs")[5]
+        except ValueError:
+            max_drawdown_abs = 0
+
+        return -1 * (total_profit * (1 - max_drawdown_abs * DRAWDOWN_MULT))

freqtrade/optimize/hyperopt_loss/hyperopt_loss_sharpe.py

@@ -0,0 +1,46 @@
+"""
+SharpeHyperOptLoss
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+from datetime import datetime
+
+import numpy as np
+from pandas import DataFrame
+
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+class SharpeHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation uses the Sharpe Ratio calculation.
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               min_date: datetime, max_date: datetime,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for more optimal results.
+
+        Uses Sharpe Ratio calculation.
+        """
+        total_profit = results["profit_ratio"]
+        days_period = (max_date - min_date).days
+
+        # adding slippage of 0.1% per trade
+        total_profit = total_profit - 0.0005
+        expected_returns_mean = total_profit.sum() / days_period
+        up_stdev = np.std(total_profit)
+
+        if up_stdev != 0:
+            sharp_ratio = expected_returns_mean / up_stdev * np.sqrt(365)
+        else:
+            # Define high (negative) sharpe ratio to be clear that this is NOT optimal.
+            sharp_ratio = -20.
+
+        # print(expected_returns_mean, up_stdev, sharp_ratio)
+        return -sharp_ratio

freqtrade/optimize/hyperopt_loss/hyperopt_loss_sharpe_daily.py

@@ -0,0 +1,62 @@
+"""
+SharpeHyperOptLossDaily
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+import math
+from datetime import datetime
+
+from pandas import DataFrame, date_range
+
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+class SharpeHyperOptLossDaily(IHyperOptLoss):
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation uses the Sharpe Ratio calculation.
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               min_date: datetime, max_date: datetime,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for more optimal results.
+
+        Uses Sharpe Ratio calculation.
+        """
+        resample_freq = '1D'
+        slippage_per_trade_ratio = 0.0005
+        days_in_year = 365
+        annual_risk_free_rate = 0.0
+        risk_free_rate = annual_risk_free_rate / days_in_year
+
+        # apply slippage per trade to profit_ratio
+        results.loc[:, 'profit_ratio_after_slippage'] = \
+            results['profit_ratio'] - slippage_per_trade_ratio
+
+        # create the index within the min_date and end max_date
+        t_index = date_range(start=min_date, end=max_date, freq=resample_freq,
+                             normalize=True)
+
+        sum_daily = (
+            results.resample(resample_freq, on='close_date').agg(
+                {"profit_ratio_after_slippage": sum}).reindex(t_index).fillna(0)
+        )
+
+        total_profit = sum_daily["profit_ratio_after_slippage"] - risk_free_rate
+        expected_returns_mean = total_profit.mean()
+        up_stdev = total_profit.std()
+
+        if up_stdev != 0:
+            sharp_ratio = expected_returns_mean / up_stdev * math.sqrt(days_in_year)
+        else:
+            # Define high (negative) sharpe ratio to be clear that this is NOT optimal.
+            sharp_ratio = -20.
+
+        # print(t_index, sum_daily, total_profit)
+        # print(risk_free_rate, expected_returns_mean, up_stdev, sharp_ratio)
+        return -sharp_ratio

freqtrade/optimize/hyperopt_loss/hyperopt_loss_short_trade_dur.py

@@ -0,0 +1,56 @@
+"""
+ShortTradeDurHyperOptLoss
+This module defines the default HyperoptLoss class which is being used for
+Hyperoptimization.
+"""
+from math import exp
+
+from pandas import DataFrame
+
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+# Set TARGET_TRADES to suit your number concurrent trades so its realistic
+# to the number of days
+TARGET_TRADES = 600
+
+# This is assumed to be expected avg profit * expected trade count.
+# For example, for 0.35% avg per trade (or 0.0035 as ratio) and 1100 trades,
+# expected max profit = 3.85
+# Check that the reported Σ% values do not exceed this!
+# Note, this is ratio. 3.85 stated above means 385Σ%.
+EXPECTED_MAX_PROFIT = 3.0
+
+# Max average trade duration in minutes.
+# If eval ends with higher value, we consider it a failed eval.
+MAX_ACCEPTED_TRADE_DURATION = 300
+
+
+class ShortTradeDurHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the default loss function for hyperopt
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for better results
+        This is the Default algorithm
+        Weights are distributed as follows:
+        * 0.4 to trade duration
+        * 0.25: Avoiding trade loss
+        * 1.0 to total profit, compared to the expected value (`EXPECTED_MAX_PROFIT`) defined above
+        """
+        total_profit = results['profit_ratio'].sum()
+        trade_duration = results['trade_duration'].mean()
+
+        trade_loss = 1 - 0.25 * exp(-(trade_count - TARGET_TRADES) ** 2 / 10 ** 5.8)
+        profit_loss = max(0, 1 - total_profit / EXPECTED_MAX_PROFIT)
+        duration_loss = 0.4 * min(trade_duration / MAX_ACCEPTED_TRADE_DURATION, 1)
+        result = trade_loss + profit_loss + duration_loss
+        return result
+
+
+# Create an alias for This to allow the legacy Method to work as well.
+DefaultHyperOptLoss = ShortTradeDurHyperOptLoss

freqtrade/optimize/hyperopt_loss/hyperopt_loss_sortino.py

@@ -0,0 +1,49 @@
+"""
+SortinoHyperOptLoss
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+from datetime import datetime
+
+import numpy as np
+from pandas import DataFrame
+
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+class SortinoHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation uses the Sortino Ratio calculation.
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               min_date: datetime, max_date: datetime,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for more optimal results.
+
+        Uses Sortino Ratio calculation.
+        """
+        total_profit = results["profit_ratio"]
+        days_period = (max_date - min_date).days
+
+        # adding slippage of 0.1% per trade
+        total_profit = total_profit - 0.0005
+        expected_returns_mean = total_profit.sum() / days_period
+
+        results['downside_returns'] = 0
+        results.loc[total_profit < 0, 'downside_returns'] = results['profit_ratio']
+        down_stdev = np.std(results['downside_returns'])
+
+        if down_stdev != 0:
+            sortino_ratio = expected_returns_mean / down_stdev * np.sqrt(365)
+        else:
+            # Define high (negative) sortino ratio to be clear that this is NOT optimal.
+            sortino_ratio = -20.
+
+        # print(expected_returns_mean, down_stdev, sortino_ratio)
+        return -sortino_ratio

freqtrade/optimize/hyperopt_loss/hyperopt_loss_sortino_daily.py

@@ -0,0 +1,70 @@
+"""
+SortinoHyperOptLossDaily
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+import math
+from datetime import datetime
+
+from pandas import DataFrame, date_range
+
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+class SortinoHyperOptLossDaily(IHyperOptLoss):
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation uses the Sortino Ratio calculation.
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               min_date: datetime, max_date: datetime,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for more optimal results.
+
+        Uses Sortino Ratio calculation.
+
+        Sortino Ratio calculated as described in
+        http://www.redrockcapital.com/Sortino__A__Sharper__Ratio_Red_Rock_Capital.pdf
+        """
+        resample_freq = '1D'
+        slippage_per_trade_ratio = 0.0005
+        days_in_year = 365
+        minimum_acceptable_return = 0.0
+
+        # apply slippage per trade to profit_ratio
+        results.loc[:, 'profit_ratio_after_slippage'] = \
+            results['profit_ratio'] - slippage_per_trade_ratio
+
+        # create the index within the min_date and end max_date
+        t_index = date_range(start=min_date, end=max_date, freq=resample_freq,
+                             normalize=True)
+
+        sum_daily = (
+            results.resample(resample_freq, on='close_date').agg(
+                {"profit_ratio_after_slippage": sum}).reindex(t_index).fillna(0)
+        )
+
+        total_profit = sum_daily["profit_ratio_after_slippage"] - minimum_acceptable_return
+        expected_returns_mean = total_profit.mean()
+
+        sum_daily['downside_returns'] = 0
+        sum_daily.loc[total_profit < 0, 'downside_returns'] = total_profit
+        total_downside = sum_daily['downside_returns']
+        # Here total_downside contains min(0, P - MAR) values,
+        # where P = sum_daily["profit_ratio_after_slippage"]
+        down_stdev = math.sqrt((total_downside**2).sum() / len(total_downside))
+
+        if down_stdev != 0:
+            sortino_ratio = expected_returns_mean / down_stdev * math.sqrt(days_in_year)
+        else:
+            # Define high (negative) sortino ratio to be clear that this is NOT optimal.
+            sortino_ratio = -20.
+
+        # print(t_index, sum_daily, total_profit)
+        # print(minimum_acceptable_return, expected_returns_mean, down_stdev, sortino_ratio)
+        return -sortino_ratio