stable/freqtrade/optimize/hyperopt.py

417 lines
16 KiB
Python
Raw Normal View History

# pragma pylint: disable=too-many-instance-attributes, pointless-string-statement
"""
This module contains the hyperopt logic
"""
import logging
import sys
2019-08-15 18:39:04 +00:00
from collections import OrderedDict
from operator import itemgetter
2019-01-06 13:47:38 +00:00
from pathlib import Path
from pprint import pprint
2019-08-02 19:22:58 +00:00
from typing import Any, Dict, List, Optional
2019-08-15 18:39:04 +00:00
import rapidjson
from colorama import init as colorama_init
2019-08-09 11:48:57 +00:00
from colorama import Fore, Style
from joblib import Parallel, delayed, dump, load, wrap_non_picklable_objects, cpu_count
2019-01-06 13:47:38 +00:00
from pandas import DataFrame
2018-06-19 06:09:54 +00:00
from skopt import Optimizer
from skopt.space import Dimension
2018-06-18 19:40:36 +00:00
from freqtrade.configuration import TimeRange
from freqtrade.data.history import load_data, get_timeframe
from freqtrade.misc import round_dict
2018-03-02 15:22:00 +00:00
from freqtrade.optimize.backtesting import Backtesting
2019-08-14 10:25:49 +00:00
# Import IHyperOpt and IHyperOptLoss to allow unpickling classes from these modules
from freqtrade.optimize.hyperopt_interface import IHyperOpt # noqa: F4
from freqtrade.optimize.hyperopt_loss_interface import IHyperOptLoss # noqa: F4
2019-07-16 04:27:23 +00:00
from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver, HyperOptLossResolver
2018-03-25 19:37:14 +00:00
logger = logging.getLogger(__name__)
2019-05-10 07:54:44 +00:00
INITIAL_POINTS = 30
MAX_LOSS = 100000 # just a big enough number to be bad result in loss optimization
2018-03-25 19:37:14 +00:00
class Hyperopt:
"""
Hyperopt class, this class contains all the logic to run a hyperopt simulation
To run a backtest:
hyperopt = Hyperopt(config)
hyperopt.start()
"""
def __init__(self, config: Dict[str, Any]) -> None:
self.config = config
self.backtesting = Backtesting(self.config)
self.custom_hyperopt = HyperOptResolver(self.config).hyperopt
2019-07-16 04:27:23 +00:00
self.custom_hyperoptloss = HyperOptLossResolver(self.config).hyperoptloss
self.calculate_loss = self.custom_hyperoptloss.hyperopt_loss_function
2019-07-31 05:07:46 +00:00
self.trials_file = (self.config['user_data_dir'] /
'hyperopt_results' / 'hyperopt_results.pickle')
self.tickerdata_pickle = (self.config['user_data_dir'] /
'hyperopt_results' / 'hyperopt_tickerdata.pkl')
self.total_epochs = config.get('epochs', 0)
self.current_best_loss = 100
2019-07-16 03:50:27 +00:00
if not self.config.get('hyperopt_continue'):
self.clean_hyperopt()
2019-07-16 03:50:27 +00:00
else:
logger.info("Continuing on previous hyperopt results.")
# Previous evaluations
2018-06-30 06:54:31 +00:00
self.trials: List = []
# Populate functions here (hasattr is slow so should not be run during "regular" operations)
if hasattr(self.custom_hyperopt, 'populate_buy_trend'):
self.backtesting.advise_buy = self.custom_hyperopt.populate_buy_trend # type: ignore
if hasattr(self.custom_hyperopt, 'populate_sell_trend'):
self.backtesting.advise_sell = self.custom_hyperopt.populate_sell_trend # type: ignore
2019-08-02 19:22:58 +00:00
# Use max_open_trades for hyperopt as well, except --disable-max-market-positions is set
if self.config.get('use_max_market_positions', True):
self.max_open_trades = self.config['max_open_trades']
else:
logger.debug('Ignoring max_open_trades (--disable-max-market-positions was used) ...')
self.max_open_trades = 0
2019-07-16 03:50:27 +00:00
self.position_stacking = self.config.get('position_stacking', False),
2019-08-01 20:57:26 +00:00
if self.has_space('sell'):
# Make sure experimental is enabled
if 'experimental' not in self.config:
self.config['experimental'] = {}
self.config['experimental']['use_sell_signal'] = True
2019-07-21 14:07:06 +00:00
@staticmethod
def get_lock_filename(config) -> str:
return str(config['user_data_dir'] / 'hyperopt.lock')
def clean_hyperopt(self):
"""
Remove hyperopt pickle files to restart hyperopt.
"""
2019-07-21 14:07:06 +00:00
for f in [self.tickerdata_pickle, self.trials_file]:
p = Path(f)
if p.is_file():
logger.info(f"Removing `{p}`.")
p.unlink()
2018-06-19 06:09:54 +00:00
def get_args(self, params):
dimensions = self.hyperopt_space()
# Ensure the number of dimensions match
# the number of parameters in the list x.
if len(params) != len(dimensions):
2018-07-03 08:17:41 +00:00
raise ValueError('Mismatch in number of search-space dimensions. '
f'len(dimensions)=={len(dimensions)} and len(x)=={len(params)}')
2018-06-19 06:09:54 +00:00
# Create a dict where the keys are the names of the dimensions
# and the values are taken from the list of parameters x.
arg_dict = {dim.name: value for dim, value in zip(dimensions, params)}
return arg_dict
def save_trials(self) -> None:
"""
Save hyperopt trials to file
"""
if self.trials:
logger.info("Saving %d evaluations to '%s'", len(self.trials), self.trials_file)
2018-07-03 19:51:48 +00:00
dump(self.trials, self.trials_file)
def read_trials(self) -> List:
"""
Read hyperopt trials file
"""
logger.info("Reading Trials from '%s'", self.trials_file)
2018-07-03 19:51:48 +00:00
trials = load(self.trials_file)
2019-07-21 13:56:44 +00:00
self.trials_file.unlink()
return trials
def log_trials_result(self) -> None:
"""
Display Best hyperopt result
"""
results = sorted(self.trials, key=itemgetter('loss'))
best_result = results[0]
2019-08-01 20:57:26 +00:00
params = best_result['params']
log_str = self.format_results_logstring(best_result)
2019-08-03 08:05:05 +00:00
print(f"\nBest result:\n\n{log_str}\n")
2019-08-15 18:39:04 +00:00
if self.config.get('print_json'):
2019-08-15 20:13:46 +00:00
result_dict: Dict = {}
2019-08-15 18:39:04 +00:00
if self.has_space('buy') or self.has_space('sell'):
result_dict['params'] = {}
if self.has_space('buy'):
result_dict['params'].update({p.name: params.get(p.name)
2019-08-15 20:13:46 +00:00
for p in self.hyperopt_space('buy')})
2019-08-15 18:39:04 +00:00
if self.has_space('sell'):
result_dict['params'].update({p.name: params.get(p.name)
2019-08-15 20:13:46 +00:00
for p in self.hyperopt_space('sell')})
2019-08-15 18:39:04 +00:00
if self.has_space('roi'):
# Convert keys in min_roi dict to strings because
# rapidjson cannot dump dicts with integer keys...
# OrderedDict is used to keep the numeric order of the items
# in the dict.
2019-08-15 20:13:46 +00:00
result_dict['minimal_roi'] = OrderedDict(
(str(k), v) for k, v in self.custom_hyperopt.generate_roi_table(params).items()
)
2019-08-15 18:39:04 +00:00
if self.has_space('stoploss'):
result_dict['stoploss'] = params.get('stoploss')
print(rapidjson.dumps(result_dict, default=str, number_mode=rapidjson.NM_NATIVE))
else:
if self.has_space('buy'):
print('Buy hyperspace params:')
pprint({p.name: params.get(p.name) for p in self.hyperopt_space('buy')},
indent=4)
if self.has_space('sell'):
print('Sell hyperspace params:')
pprint({p.name: params.get(p.name) for p in self.hyperopt_space('sell')},
indent=4)
if self.has_space('roi'):
print("ROI table:")
# Round printed values to 5 digits after the decimal point
pprint(round_dict(self.custom_hyperopt.generate_roi_table(params), 5), indent=4)
2019-08-15 18:39:04 +00:00
if self.has_space('stoploss'):
# Also round to 5 digits after the decimal point
print(f"Stoploss: {round(params.get('stoploss'), 5)}")
def log_results(self, results) -> None:
"""
Log results if it is better than any previous evaluation
"""
2019-05-10 07:54:44 +00:00
print_all = self.config.get('print_all', False)
2019-08-03 16:09:42 +00:00
is_best_loss = results['loss'] < self.current_best_loss
if print_all or is_best_loss:
if is_best_loss:
self.current_best_loss = results['loss']
log_str = self.format_results_logstring(results)
2019-08-03 16:09:42 +00:00
# Colorize output
if self.config.get('print_colorized', False):
if results['total_profit'] > 0:
2019-08-09 11:48:57 +00:00
log_str = Fore.GREEN + log_str
if print_all and is_best_loss:
log_str = Style.BRIGHT + log_str
2019-05-10 07:54:44 +00:00
if print_all:
print(log_str)
2019-05-10 07:54:44 +00:00
else:
print('\n' + log_str)
else:
print('.', end='')
sys.stdout.flush()
def format_results_logstring(self, results) -> str:
# Output human-friendly index here (starting from 1)
current = results['current_epoch'] + 1
total = self.total_epochs
res = results['results_explanation']
loss = results['loss']
log_str = f'{current:5d}/{total}: {res} Objective: {loss:.5f}'
log_str = f'*{log_str}' if results['is_initial_point'] else f' {log_str}'
return log_str
2018-03-17 21:43:36 +00:00
def has_space(self, space: str) -> bool:
"""
Tell if a space value is contained in the configuration
"""
2019-08-01 20:57:26 +00:00
return any(s in self.config['spaces'] for s in [space, 'all'])
2019-08-02 19:22:58 +00:00
def hyperopt_space(self, space: Optional[str] = None) -> List[Dimension]:
"""
2019-08-03 07:20:20 +00:00
Return the dimensions in the hyperoptimization space.
:param space: Defines hyperspace to return dimensions for.
If None, then the self.has_space() will be used to return dimensions
2019-08-02 19:22:58 +00:00
for all hyperspaces used.
"""
spaces: List[Dimension] = []
2019-08-02 19:22:58 +00:00
if space == 'buy' or (space is None and self.has_space('buy')):
2019-08-01 20:57:26 +00:00
logger.debug("Hyperopt has 'buy' space")
2018-11-07 18:46:04 +00:00
spaces += self.custom_hyperopt.indicator_space()
2019-08-02 19:22:58 +00:00
if space == 'sell' or (space is None and self.has_space('sell')):
2019-08-01 20:57:26 +00:00
logger.debug("Hyperopt has 'sell' space")
2019-01-06 09:16:30 +00:00
spaces += self.custom_hyperopt.sell_indicator_space()
2019-08-02 19:22:58 +00:00
if space == 'roi' or (space is None and self.has_space('roi')):
2019-08-01 20:57:26 +00:00
logger.debug("Hyperopt has 'roi' space")
2018-11-07 18:46:04 +00:00
spaces += self.custom_hyperopt.roi_space()
2019-08-02 19:22:58 +00:00
if space == 'stoploss' or (space is None and self.has_space('stoploss')):
2019-08-01 20:57:26 +00:00
logger.debug("Hyperopt has 'stoploss' space")
2018-11-07 18:46:04 +00:00
spaces += self.custom_hyperopt.stoploss_space()
return spaces
2017-12-26 08:08:10 +00:00
2018-11-07 18:46:04 +00:00
def generate_optimizer(self, _params: Dict) -> Dict:
"""
Used Optimize function. Called once per epoch to optimize whatever is configured.
Keep this function as optimized as possible!
"""
2018-11-07 18:46:04 +00:00
params = self.get_args(_params)
if self.has_space('roi'):
self.backtesting.strategy.minimal_roi = self.custom_hyperopt.generate_roi_table(params)
if self.has_space('buy'):
self.backtesting.advise_buy = self.custom_hyperopt.buy_strategy_generator(params)
2019-01-06 09:16:30 +00:00
if self.has_space('sell'):
self.backtesting.advise_sell = self.custom_hyperopt.sell_strategy_generator(params)
2019-01-06 09:16:30 +00:00
if self.has_space('stoploss'):
self.backtesting.strategy.stoploss = params['stoploss']
2019-07-21 14:07:06 +00:00
processed = load(self.tickerdata_pickle)
2019-07-14 17:56:17 +00:00
2018-11-04 12:43:09 +00:00
min_date, max_date = get_timeframe(processed)
2019-07-14 17:56:17 +00:00
results = self.backtesting.backtest(
{
'stake_amount': self.config['stake_amount'],
'processed': processed,
'max_open_trades': self.max_open_trades,
2019-07-16 03:50:27 +00:00
'position_stacking': self.position_stacking,
2018-10-16 17:35:16 +00:00
'start_date': min_date,
'end_date': max_date,
}
)
results_explanation = self.format_results(results)
trade_count = len(results.index)
2019-08-03 16:09:42 +00:00
total_profit = results.profit_abs.sum()
# If this evaluation contains too short amount of trades to be
# interesting -- consider it as 'bad' (assigned max. loss value)
2019-05-01 12:27:58 +00:00
# in order to cast this hyperspace point away from optimization
# path. We do not want to optimize 'hodl' strategies.
if trade_count < self.config['hyperopt_min_trades']:
return {
'loss': MAX_LOSS,
'params': params,
'results_explanation': results_explanation,
2019-08-03 16:09:42 +00:00
'total_profit': total_profit,
}
loss = self.calculate_loss(results=results, trade_count=trade_count,
min_date=min_date.datetime, max_date=max_date.datetime)
2018-06-19 18:57:42 +00:00
return {
'loss': loss,
'params': params,
'results_explanation': results_explanation,
2019-08-03 16:09:42 +00:00
'total_profit': total_profit,
2018-06-19 18:57:42 +00:00
}
def format_results(self, results: DataFrame) -> str:
"""
Return the formatted results explanation in a string
"""
trades = len(results.index)
avg_profit = results.profit_percent.mean() * 100.0
total_profit = results.profit_abs.sum()
stake_cur = self.config['stake_currency']
profit = results.profit_percent.sum() * 100.0
duration = results.trade_duration.mean()
return (f'{trades:6d} trades. Avg profit {avg_profit: 5.2f}%. '
f'Total profit {total_profit: 11.8f} {stake_cur} '
f'({profit: 7.2f}Σ%). Avg duration {duration:5.1f} mins.')
2018-07-03 08:46:56 +00:00
def get_optimizer(self, cpu_count) -> Optimizer:
2018-06-24 12:27:53 +00:00
return Optimizer(
self.hyperopt_space(),
base_estimator="ET",
acq_optimizer="auto",
2019-05-10 07:54:44 +00:00
n_initial_points=INITIAL_POINTS,
acq_optimizer_kwargs={'n_jobs': cpu_count},
random_state=self.config.get('hyperopt_random_state', None)
2018-06-24 12:27:53 +00:00
)
def run_optimizer_parallel(self, parallel, asked) -> List:
2018-11-20 16:43:49 +00:00
return parallel(delayed(
wrap_non_picklable_objects(self.generate_optimizer))(v) for v in asked)
2018-06-24 12:27:53 +00:00
def load_previous_results(self):
""" read trials file if we have one """
2019-07-21 13:56:44 +00:00
if self.trials_file.is_file() and self.trials_file.stat().st_size > 0:
self.trials = self.read_trials()
logger.info(
'Loaded %d previous evaluations from disk.',
len(self.trials)
)
2018-03-17 21:43:36 +00:00
def start(self) -> None:
timerange = TimeRange.parse_timerange(None if self.config.get(
2018-06-02 11:43:51 +00:00
'timerange') is None else str(self.config.get('timerange')))
2018-06-05 21:34:26 +00:00
data = load_data(
datadir=Path(self.config['datadir']),
pairs=self.config['exchange']['pair_whitelist'],
ticker_interval=self.backtesting.ticker_interval,
refresh_pairs=self.config.get('refresh_pairs', False),
exchange=self.backtesting.exchange,
timerange=timerange
)
if not data:
logger.critical("No data found. Terminating.")
return
min_date, max_date = get_timeframe(data)
logger.info(
'Hyperopting with data from %s up to %s (%s days)..',
min_date.isoformat(),
max_date.isoformat(),
(max_date - min_date).days
)
self.backtesting.strategy.advise_indicators = \
2019-07-11 20:02:57 +00:00
self.custom_hyperopt.populate_indicators # type: ignore
preprocessed = self.backtesting.strategy.tickerdata_to_dataframe(data)
2019-06-09 23:08:54 +00:00
2019-07-21 14:07:06 +00:00
dump(preprocessed, self.tickerdata_pickle)
# We don't need exchange instance anymore while running hyperopt
self.backtesting.exchange = None # type: ignore
self.load_previous_results()
cpus = cpu_count()
logger.info(f"Found {cpus} CPU cores. Let's make them scream!")
config_jobs = self.config.get('hyperopt_jobs', -1)
logger.info(f'Number of parallel jobs set as: {config_jobs}')
2018-06-21 11:59:36 +00:00
opt = self.get_optimizer(config_jobs)
2019-08-09 11:48:57 +00:00
if self.config.get('print_colorized', False):
colorama_init(autoreset=True)
try:
with Parallel(n_jobs=config_jobs) as parallel:
jobs = parallel._effective_n_jobs()
logger.info(f'Effective number of parallel workers used: {jobs}')
EVALS = max(self.total_epochs // jobs, 1)
2018-07-03 18:54:32 +00:00
for i in range(EVALS):
asked = opt.ask(n_points=jobs)
2018-06-24 12:27:53 +00:00
f_val = self.run_optimizer_parallel(parallel, asked)
opt.tell(asked, [v['loss'] for v in f_val])
for j in range(jobs):
2019-05-10 07:54:44 +00:00
current = i * jobs + j
val = f_val[j]
val['current_epoch'] = current
val['is_initial_point'] = current < INITIAL_POINTS
self.log_results(val)
self.trials.append(val)
logger.debug(f"Optimizer epoch evaluated: {val}")
except KeyboardInterrupt:
print('User interrupted..')
self.save_trials()
self.log_trials_result()