Add sharpe ratio hyperopt loss

freqtrade/configuration/configuration.py

@@ -288,7 +288,7 @@ class Configuration(object):
         self._args_to_config(config, argname='hyperopt_continue',
                              logstring='Hyperopt continue: {}')
 
-        self._args_to_config(config, argname='loss_function',
+        self._args_to_config(config, argname='hyperopt_loss',
                              logstring='Using loss function: {}')
 
         return config

freqtrade/optimize/default_hyperopt_loss.py

@@ -1,6 +1,7 @@
 """
-IHyperOptLoss interface
+DefaultHyperOptLoss
-This module defines the interface for the loss-function for hyperopts
+This module defines the default HyperoptLoss class which is being used for
+Hyperoptimization.
 """
 
 from math import exp

freqtrade/optimize/hyperopt_loss_sharpe.py

@@ -0,0 +1,42 @@
+"""
+IHyperOptLoss interface
+This module defines the interface for the loss-function for hyperopts
+"""
+
+from datetime import datetime
+
+from pandas import DataFrame
+import numpy as np
+
+from freqtrade.optimize.hyperopt_loss_interface import IHyperOptLoss
+
+
+class SharpeHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the a 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
+        Using sharpe ratio calculation
+        """
+        total_profit = results.profit_percent
+        days_period = (max_date - min_date).days
+
+        # adding slippage of 0.1% per trade
+        total_profit = total_profit - 0.0005
+        expected_yearly_return = total_profit.sum() / days_period
+
+        if (np.std(total_profit) != 0.):
+            sharp_ratio = expected_yearly_return / np.std(total_profit) * np.sqrt(365)
+        else:
+            # Define high (negative) sharpe ratio to be clear that this is NOT optimal.
+            sharp_ratio = 20.
+
+        # print(expected_yearly_return, np.std(total_profit), sharp_ratio)
+        return -sharp_ratio

freqtrade/tests/optimize/test_hyperopt.py

@@ -15,8 +15,7 @@ from freqtrade.optimize import setup_configuration, start_hyperopt
 from freqtrade.optimize.default_hyperopt import DefaultHyperOpts
 from freqtrade.optimize.hyperopt import (HYPEROPT_LOCKFILE, TICKERDATA_PICKLE,
                                          Hyperopt)
-from freqtrade.optimize.hyperopt_loss import hyperopt_loss_legacy, hyperopt_loss_sharpe
+from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver, HyperOptLossResolver
-from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver
 from freqtrade.state import RunMode
 from freqtrade.strategy.interface import SellType
 from freqtrade.tests.conftest import (get_args, log_has, log_has_re,
@@ -274,48 +273,53 @@ def test_start_filelock(mocker, default_conf, caplog) -> None:
     )
 
 
-def test_loss_calculation_prefer_correct_trade_count(hyperopt_results) -> None:
+def test_loss_calculation_prefer_correct_trade_count(default_conf, hyperopt_results) -> None:
-    correct = hyperopt_loss_legacy(hyperopt_results, 600)
+    hl = HyperOptLossResolver(default_conf).hyperoptloss
-    over = hyperopt_loss_legacy(hyperopt_results, 600 + 100)
+    correct = hl.hyperopt_loss_function(hyperopt_results, 600)
-    under = hyperopt_loss_legacy(hyperopt_results, 600 - 100)
+    over = hl.hyperopt_loss_function(hyperopt_results, 600 + 100)
+    under = hl.hyperopt_loss_function(hyperopt_results, 600 - 100)
     assert over > correct
     assert under > correct
 
 
-def test_loss_calculation_prefer_shorter_trades(hyperopt_results) -> None:
+def test_loss_calculation_prefer_shorter_trades(default_conf, hyperopt_results) -> None:
     resultsb = hyperopt_results.copy()
     resultsb['trade_duration'][1] = 20
 
-    longer = hyperopt_loss_legacy(hyperopt_results, 100)
+    hl = HyperOptLossResolver(default_conf).hyperoptloss
-    shorter = hyperopt_loss_legacy(resultsb, 100)
+    longer = hl.hyperopt_loss_function(hyperopt_results, 100)
+    shorter = hl.hyperopt_loss_function(resultsb, 100)
     assert shorter < longer
 
 
-def test_loss_calculation_has_limited_profit(hyperopt_results) -> None:
+def test_loss_calculation_has_limited_profit(default_conf, hyperopt_results) -> None:
     results_over = hyperopt_results.copy()
     results_over['profit_percent'] = hyperopt_results['profit_percent'] * 2
     results_under = hyperopt_results.copy()
     results_under['profit_percent'] = hyperopt_results['profit_percent'] / 2
 
-    correct = hyperopt_loss_legacy(hyperopt_results, 600)
+    hl = HyperOptLossResolver(default_conf).hyperoptloss
-    over = hyperopt_loss_legacy(results_over, 600)
+    correct = hl.hyperopt_loss_function(hyperopt_results, 600)
-    under = hyperopt_loss_legacy(results_under, 600)
+    over = hl.hyperopt_loss_function(results_over, 600)
+    under = hl.hyperopt_loss_function(results_under, 600)
     assert over < correct
     assert under > correct
 
 
-def test_sharpe_loss_prefers_higher_profits(hyperopt_results) -> None:
+def test_sharpe_loss_prefers_higher_profits(default_conf, hyperopt_results) -> None:
     results_over = hyperopt_results.copy()
     results_over['profit_percent'] = hyperopt_results['profit_percent'] * 2
     results_under = hyperopt_results.copy()
     results_under['profit_percent'] = hyperopt_results['profit_percent'] / 2
 
-    correct = hyperopt_loss_sharpe(hyperopt_results, len(
+    default_conf.update({'hyperopt_loss': 'SharpeHyperOptLoss'})
-        hyperopt_results), datetime(2019, 1, 1), datetime(2019, 5, 1))
+    hl = HyperOptLossResolver(default_conf).hyperoptloss
-    over = hyperopt_loss_sharpe(results_over, len(hyperopt_results),
+    correct = hl.hyperopt_loss_function(hyperopt_results, len(hyperopt_results),
-                                datetime(2019, 1, 1), datetime(2019, 5, 1))
+                                        datetime(2019, 1, 1), datetime(2019, 5, 1))
-    under = hyperopt_loss_sharpe(results_under, len(hyperopt_results),
+    over = hl.hyperopt_loss_function(results_over, len(hyperopt_results),
-                                 datetime(2019, 1, 1), datetime(2019, 5, 1))
+                                     datetime(2019, 1, 1), datetime(2019, 5, 1))
+    under = hl.hyperopt_loss_function(results_under, len(hyperopt_results),
+                                      datetime(2019, 1, 1), datetime(2019, 5, 1))
     assert over < correct
     assert under > correct