Merge pull request freqtrade#11558 from viotemp1/optuna

switch hyperopt from scikit-optimize to  Optuna

Author: xmatthias

docs/advanced-hyperopt.md

@@ -161,56 +161,53 @@ class MyAwesomeStrategy(IStrategy):
 
 ### Overriding Base estimator
 
-You can define your own estimator for Hyperopt by implementing `generate_estimator()` in the Hyperopt subclass.
+You can define your own optuna sampler for Hyperopt by implementing `generate_estimator()` in the Hyperopt subclass.
 
 ```python
 class MyAwesomeStrategy(IStrategy):
     class HyperOpt:
         def generate_estimator(dimensions: List['Dimension'], **kwargs):
-            return "RF"
+            return "NSGAIIISampler"
 
 ```
 
-Possible values are either one of "GP", "RF", "ET", "GBRT" (Details can be found in the [scikit-optimize documentation](https://scikit-optimize.github.io/)), or "an instance of a class that inherits from `RegressorMixin` (from sklearn) and where the `predict` method has an optional `return_std` argument, which returns `std(Y | x)` along with `E[Y | x]`".
+Possible values are either one of "NSGAIISampler", "TPESampler", "GPSampler", "CmaEsSampler", "NSGAIIISampler", "QMCSampler" (Details can be found in the [optuna-samplers documentation](https://optuna.readthedocs.io/en/stable/reference/samplers/index.html)), or "an instance of a class that inherits from `optuna.samplers.BaseSampler`".
 
-Some research will be necessary to find additional Regressors.
+Some research will be necessary to find additional Samplers (from optunahub) for example.
 
-Example for `ExtraTreesRegressor` ("ET") with additional parameters:
+!!! Note
+    While custom estimators can be provided, it's up to you as User to do research on possible parameters and analyze / understand which ones should be used.
+    If you're unsure about this, best use one of the Defaults (`"NSGAIIISampler"` has proven to be the most versatile) without further parameters.
 
-```python
-class MyAwesomeStrategy(IStrategy):
-    class HyperOpt:
-        def generate_estimator(dimensions: List['Dimension'], **kwargs):
-            from skopt.learning import ExtraTreesRegressor
-            # Corresponds to "ET" - but allows additional parameters.
-            return ExtraTreesRegressor(n_estimators=100)
+??? Example "Using `AutoSampler` from Optunahub"
 
-```
+    [AutoSampler docs](https://hub.optuna.org/samplers/auto_sampler/)
+    
+    Install the necessary dependencies 
+    ``` bash
+    pip install optunahub cmaes torch scipy
+    ```
+    Implement `generate_estimator()`  in your strategy
 
-The `dimensions` parameter is the list of `skopt.space.Dimension` objects corresponding to the parameters to be optimized. It can be used to create isotropic kernels for the `skopt.learning.GaussianProcessRegressor` estimator. Here's an example:
+    ``` python
+    # ...
+    from freqtrade.strategy.interface import IStrategy
+    from typing import List
+    import optunahub
+    # ... 
 
-```python
-class MyAwesomeStrategy(IStrategy):
-    class HyperOpt:
-        def generate_estimator(dimensions: List['Dimension'], **kwargs):
-            from skopt.utils import cook_estimator
-            from skopt.learning.gaussian_process.kernels import (Matern, ConstantKernel)
-            kernel_bounds = (0.0001, 10000)
-            kernel = (
-                ConstantKernel(1.0, kernel_bounds) * 
-                Matern(length_scale=np.ones(len(dimensions)), length_scale_bounds=[kernel_bounds for d in dimensions], nu=2.5)
-            )
-            kernel += (
-                ConstantKernel(1.0, kernel_bounds) * 
-                Matern(length_scale=np.ones(len(dimensions)), length_scale_bounds=[kernel_bounds for d in dimensions], nu=1.5)
-            )
-
-            return cook_estimator("GP", space=dimensions, kernel=kernel, n_restarts_optimizer=2)
-```
+    class my_strategy(IStrategy):
+        class HyperOpt:
+            def generate_estimator(dimensions: List["Dimension"], **kwargs):
+                if "random_state" in kwargs.keys():
+                    return optunahub.load_module("samplers/auto_sampler").AutoSampler(seed=kwargs["random_state"])
+                else:
+                    return optunahub.load_module("samplers/auto_sampler").AutoSampler()
+
+    ```
+
+    Obviously the same approach will work for all other Samplers optuna supports.
 
-!!! Note
-    While custom estimators can be provided, it's up to you as User to do research on possible parameters and analyze / understand which ones should be used.
-    If you're unsure about this, best use one of the Defaults (`"ET"` has proven to be the most versatile) without further parameters.
 
 ## Space options
 

docs/faq.md

@@ -219,10 +219,7 @@ On Windows, the `--logfile` option is also supported by Freqtrade and you can us
 First of all, most indicator libraries don't have GPU support - as such, there would be little benefit for indicator calculations.
 The GPU improvements would only apply to pandas-native calculations - or ones written by yourself.
 
-For hyperopt, freqtrade is using scikit-optimize, which is built on top of scikit-learn.
-Their statement about GPU support is [pretty clear](https://scikit-learn.org/stable/faq.html#will-you-add-gpu-support).
-
-GPU's also are only good at crunching numbers (floating point operations).
+GPU's are only good at crunching numbers (floating point operations).
 For hyperopt, we need both number-crunching (find next parameters) and running python code (running backtesting).
 As such, GPU's are not too well suited for most parts of hyperopt.
 

docs/hyperopt.md

@@ -1,10 +1,10 @@
 # Hyperopt
 
 This page explains how to tune your strategy by finding the optimal
-parameters, a process called hyperparameter optimization. The bot uses algorithms included in the `scikit-optimize` package to accomplish this.
+parameters, a process called hyperparameter optimization. The bot uses algorithms included in the `optuna` package to accomplish this.
 The search will burn all your CPU cores, make your laptop sound like a fighter jet and still take a long time.
 
-In general, the search for best parameters starts with a few random combinations (see [below](#reproducible-results) for more details) and then uses Bayesian search with a ML regressor algorithm (currently ExtraTreesRegressor) to quickly find a combination of parameters in the search hyperspace that minimizes the value of the [loss function](#loss-functions).
+In general, the search for best parameters starts with a few random combinations (see [below](#reproducible-results) for more details) and then uses one of optuna's sampler algorithms (currently NSGAIIISampler) to quickly find a combination of parameters in the search hyperspace that minimizes the value of the [loss function](#loss-functions).
 
 Hyperopt requires historic data to be available, just as backtesting does (hyperopt runs backtesting many times with different parameters).
 To learn how to get data for the pairs and exchange you're interested in, head over to the [Data Downloading](data-download.md) section of the documentation.

freqtrade/optimize/hyperopt/hyperopt.py

@@ -4,6 +4,7 @@
 This module contains the hyperopt logic
 """
 
+import gc
 import logging
 import random
 from datetime import datetime
@@ -13,7 +14,7 @@
 from typing import Any
 
 import rapidjson
-from joblib import Parallel, cpu_count, delayed, wrap_non_picklable_objects
+from joblib import Parallel, cpu_count
 
 from freqtrade.constants import FTHYPT_FILEVERSION, LAST_BT_RESULT_FN, Config
 from freqtrade.enums import HyperoptState
@@ -35,9 +36,6 @@
 
 INITIAL_POINTS = 30
 
-# Keep no more than SKOPT_MODEL_QUEUE_SIZE models
-# in the skopt model queue, to optimize memory consumption
-SKOPT_MODEL_QUEUE_SIZE = 10
 
 log_queue: Any
 
@@ -92,7 +90,7 @@ def __init__(self, config: Config) -> None:
         self.hyperopt_table_header = 0
         self.print_json = self.config.get("print_json", False)
 
-        self.hyperopter = HyperOptimizer(self.config)
+        self.hyperopter = HyperOptimizer(self.config, self.data_pickle_file)
 
     @staticmethod
     def get_lock_filename(config: Config) -> str:
@@ -158,14 +156,20 @@ def optimizer_wrapper(*args, **kwargs):
                 log_queue, logging.INFO if self.config["verbosity"] < 1 else logging.DEBUG
             )
 
-            return self.hyperopter.generate_optimizer(*args, **kwargs)
+            return self.hyperopter.generate_optimizer_wrapped(*args, **kwargs)
 
-        return parallel(delayed(wrap_non_picklable_objects(optimizer_wrapper))(v) for v in asked)
+        return parallel(optimizer_wrapper(v) for v in asked)
 
     def _set_random_state(self, random_state: int | None) -> int:
         return random_state or random.randint(1, 2**16 - 1)  # noqa: S311
 
-    def get_asked_points(self, n_points: int) -> tuple[list[list[Any]], list[bool]]:
+    def get_optuna_asked_points(self, n_points: int, dimensions: dict) -> list[Any]:
+        asked: list[list[Any]] = []
+        for i in range(n_points):
+            asked.append(self.opt.ask(dimensions))
+        return asked
+
+    def get_asked_points(self, n_points: int, dimensions: dict) -> tuple[list[Any], list[bool]]:
         """
         Enforce points returned from `self.opt.ask` have not been already evaluated
 
@@ -191,19 +195,19 @@ def unique_list(a_list):
         while i < 5 and len(asked_non_tried) < n_points:
             if i < 3:
                 self.opt.cache_ = {}
-                asked = unique_list(self.opt.ask(n_points=n_points * 5 if i > 0 else n_points))
+                asked = unique_list(
+                    self.get_optuna_asked_points(
+                        n_points=n_points * 5 if i > 0 else n_points, dimensions=dimensions
+                    )
+                )
                 is_random = [False for _ in range(len(asked))]
             else:
                 asked = unique_list(self.opt.space.rvs(n_samples=n_points * 5))
                 is_random = [True for _ in range(len(asked))]
             is_random_non_tried += [
-                rand
-                for x, rand in zip(asked, is_random, strict=False)
-                if x not in self.opt.Xi and x not in asked_non_tried
-            ]
-            asked_non_tried += [
-                x for x in asked if x not in self.opt.Xi and x not in asked_non_tried
+                rand for x, rand in zip(asked, is_random, strict=False) if x not in asked_non_tried
             ]
+            asked_non_tried += [x for x in asked if x not in asked_non_tried]
             i += 1
 
         if asked_non_tried:
@@ -212,7 +216,9 @@ def unique_list(a_list):
                 is_random_non_tried[: min(len(asked_non_tried), n_points)],
             )
         else:
-            return self.opt.ask(n_points=n_points), [False for _ in range(n_points)]
+            return self.get_optuna_asked_points(n_points=n_points, dimensions=dimensions), [
+                False for _ in range(n_points)
+            ]
 
     def evaluate_result(self, val: dict[str, Any], current: int, is_random: bool):
         """
@@ -258,9 +264,7 @@ def start(self) -> None:
         config_jobs = self.config.get("hyperopt_jobs", -1)
         logger.info(f"Number of parallel jobs set as: {config_jobs}")
 
-        self.opt = self.hyperopter.get_optimizer(
-            config_jobs, self.random_state, INITIAL_POINTS, SKOPT_MODEL_QUEUE_SIZE
-        )
+        self.opt = self.hyperopter.get_optimizer(self.random_state)
         self._setup_logging_mp_workaround()
         try:
             with Parallel(n_jobs=config_jobs) as parallel:
@@ -276,9 +280,11 @@ def start(self) -> None:
                     if self.analyze_per_epoch:
                         # First analysis not in parallel mode when using --analyze-per-epoch.
                         # This allows dataprovider to load it's informative cache.
-                        asked, is_random = self.get_asked_points(n_points=1)
-                        f_val0 = self.hyperopter.generate_optimizer(asked[0])
-                        self.opt.tell(asked, [f_val0["loss"]])
+                        asked, is_random = self.get_asked_points(
+                            n_points=1, dimensions=self.hyperopter.o_dimensions
+                        )
+                        f_val0 = self.hyperopter.generate_optimizer(asked[0].params)
+                        self.opt.tell(asked[0], [f_val0["loss"]])
                         self.evaluate_result(f_val0, 1, is_random[0])
                         pbar.update(task, advance=1)
                         start += 1
@@ -290,9 +296,17 @@ def start(self) -> None:
                         n_rest = (i + 1) * jobs - (self.total_epochs - start)
                         current_jobs = jobs - n_rest if n_rest > 0 else jobs
 
-                        asked, is_random = self.get_asked_points(n_points=current_jobs)
-                        f_val = self.run_optimizer_parallel(parallel, asked)
-                        self.opt.tell(asked, [v["loss"] for v in f_val])
+                        asked, is_random = self.get_asked_points(
+                            n_points=current_jobs, dimensions=self.hyperopter.o_dimensions
+                        )
+
+                        f_val = self.run_optimizer_parallel(
+                            parallel,
+                            [asked1.params for asked1 in asked],
+                        )
+                        f_val_loss = [v["loss"] for v in f_val]
+                        for o_ask, v in zip(asked, f_val_loss, strict=False):
+                            self.opt.tell(o_ask, v)
 
                         for j, val in enumerate(f_val):
                             # Use human-friendly indexes here (starting from 1)
@@ -301,6 +315,7 @@ def start(self) -> None:
                             self.evaluate_result(val, current, is_random[j])
                             pbar.update(task, advance=1)
                         logging_mp_handle(log_queue)
+                        gc.collect()
 
         except KeyboardInterrupt:
             print("User interrupted..")

freqtrade/optimize/hyperopt/hyperopt_auto.py

@@ -12,7 +12,7 @@
 
 
 with suppress(ImportError):
-    from skopt.space import Dimension
+    from freqtrade.optimize.space import Dimension
 
 from freqtrade.optimize.hyperopt.hyperopt_interface import EstimatorType, IHyperOpt
 

freqtrade/optimize/hyperopt/hyperopt_interface.py

@@ -8,19 +8,18 @@
 from abc import ABC
 from typing import TypeAlias
 
-from sklearn.base import RegressorMixin
-from skopt.space import Categorical, Dimension, Integer
+from optuna.samplers import BaseSampler
 
 from freqtrade.constants import Config
 from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.misc import round_dict
-from freqtrade.optimize.space import SKDecimal
+from freqtrade.optimize.space import Categorical, Dimension, Integer, SKDecimal
 from freqtrade.strategy import IStrategy
 
 
 logger = logging.getLogger(__name__)
 
-EstimatorType: TypeAlias = RegressorMixin | str
+EstimatorType: TypeAlias = BaseSampler | str
 
 
 class IHyperOpt(ABC):
@@ -44,10 +43,11 @@ def __init__(self, config: Config) -> None:
     def generate_estimator(self, dimensions: list[Dimension], **kwargs) -> EstimatorType:
         """
         Return base_estimator.
-        Can be any of "GP", "RF", "ET", "GBRT" or an instance of a class
-        inheriting from RegressorMixin (from sklearn).
+        Can be any of "TPESampler", "GPSampler", "CmaEsSampler", "NSGAIISampler"
+        "NSGAIIISampler", "QMCSampler" or an instance of a class
+        inheriting from BaseSampler (from optuna.samplers).
         """
-        return "ET"
+        return "NSGAIIISampler"
 
     def generate_roi_table(self, params: dict) -> dict[int, float]:
         """