stable/freqtrade/optimize/hyperopt.py

420 lines
14 KiB
Python
Raw Normal View History

# pragma pylint: disable=too-many-instance-attributes, pointless-string-statement
"""
This module contains the hyperopt logic
"""
2017-11-25 00:22:36 +00:00
import json
import logging
import os
import pickle
import signal
import sys
2018-06-19 06:09:54 +00:00
import multiprocessing
2018-03-17 21:43:36 +00:00
from argparse import Namespace
from functools import reduce
from math import exp
from operator import itemgetter
from typing import Dict, Any, Callable, Optional, List
import numpy
import talib.abstract as ta
from hyperopt import STATUS_FAIL, STATUS_OK, Trials, fmin, hp, space_eval, tpe
from pandas import DataFrame
from skopt.space import Real, Integer, Categorical, Dimension
2018-06-19 06:09:54 +00:00
from skopt import Optimizer
from sklearn.externals.joblib import Parallel, delayed
2018-06-18 19:40:36 +00:00
import freqtrade.vendor.qtpylib.indicators as qtpylib
2018-03-17 21:44:47 +00:00
from freqtrade.arguments import Arguments
from freqtrade.configuration import Configuration
from freqtrade.optimize import load_data
2018-03-02 15:22:00 +00:00
from freqtrade.optimize.backtesting import Backtesting
2018-03-25 19:37:14 +00:00
logger = logging.getLogger(__name__)
class Hyperopt(Backtesting):
"""
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:
super().__init__(config)
# set TARGET_TRADES to suit your number concurrent trades so its realistic
# to the number of days
self.target_trades = 600
self.total_tries = config.get('epochs', 0)
self.current_best_loss = 100
# max average trade duration in minutes
# if eval ends with higher value, we consider it a failed eval
self.max_accepted_trade_duration = 300
# this is expexted avg profit * expected trade count
# for example 3.5%, 1100 trades, self.expected_max_profit = 3.85
# check that the reported Σ% values do not exceed this!
self.expected_max_profit = 3.0
# Configuration and data used by hyperopt
2018-05-31 20:00:46 +00:00
self.processed: Optional[Dict[str, Any]] = None
# Hyperopt Trials
self.trials_file = os.path.join('user_data', 'hyperopt_trials.pickle')
self.trials = Trials()
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):
msg = "Mismatch in number of search-space dimensions. " \
"len(dimensions)=={} and len(x)=={}"
msg = msg.format(len(dimensions), len(params))
raise ValueError(msg)
# 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
@staticmethod
def populate_indicators(dataframe: DataFrame) -> DataFrame:
dataframe['adx'] = ta.ADX(dataframe)
macd = ta.MACD(dataframe)
dataframe['macd'] = macd['macd']
dataframe['macdsignal'] = macd['macdsignal']
dataframe['mfi'] = ta.MFI(dataframe)
dataframe['rsi'] = ta.RSI(dataframe)
stoch_fast = ta.STOCHF(dataframe)
dataframe['fastd'] = stoch_fast['fastd']
2018-06-18 19:40:36 +00:00
dataframe['minus_di'] = ta.MINUS_DI(dataframe)
# Bollinger bands
bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
dataframe['bb_lowerband'] = bollinger['lower']
return dataframe
def save_trials(self) -> None:
"""
Save hyperopt trials to file
"""
2018-03-25 19:37:14 +00:00
logger.info('Saving Trials to \'%s\'', self.trials_file)
pickle.dump(self.trials, open(self.trials_file, 'wb'))
def read_trials(self) -> Trials:
"""
Read hyperopt trials file
"""
2018-03-25 19:37:14 +00:00
logger.info('Reading Trials from \'%s\'', self.trials_file)
trials = pickle.load(open(self.trials_file, 'rb'))
os.remove(self.trials_file)
return trials
def log_trials_result(self) -> None:
"""
Display Best hyperopt result
"""
vals = json.dumps(self.trials.best_trial['misc']['vals'], indent=4)
results = self.trials.best_trial['result']['result']
2018-03-25 19:37:14 +00:00
logger.info('Best result:\n%s\nwith values:\n%s', results, vals)
def log_results(self, results) -> None:
"""
Log results if it is better than any previous evaluation
"""
if results['loss'] < self.current_best_loss:
self.current_best_loss = results['loss']
log_msg = '\n{:5d}/{}: {}. Loss {:.5f}'.format(
results['current_tries'],
results['total_tries'],
results['result'],
results['loss']
)
print(log_msg)
else:
print('.', end='')
sys.stdout.flush()
def calculate_loss(self, total_profit: float, trade_count: int, trade_duration: float) -> float:
"""
Objective function, returns smaller number for more optimal results
"""
trade_loss = 1 - 0.25 * exp(-(trade_count - self.target_trades) ** 2 / 10 ** 5.8)
profit_loss = max(0, 1 - total_profit / self.expected_max_profit)
duration_loss = 0.4 * min(trade_duration / self.max_accepted_trade_duration, 1)
return trade_loss + profit_loss + duration_loss
@staticmethod
2018-03-17 21:43:36 +00:00
def generate_roi_table(params: Dict) -> Dict[int, float]:
"""
Generate the ROI table thqt will be used by Hyperopt
"""
roi_table = {}
roi_table[0] = params['roi_p1'] + params['roi_p2'] + params['roi_p3']
roi_table[params['roi_t3']] = params['roi_p1'] + params['roi_p2']
roi_table[params['roi_t3'] + params['roi_t2']] = params['roi_p1']
roi_table[params['roi_t3'] + params['roi_t2'] + params['roi_t1']] = 0
return roi_table
@staticmethod
def roi_space() -> List[Dimension]:
"""
Values to search for each ROI steps
"""
return [
Integer(10, 120, name='roi_t1'),
Integer(10, 60, name='roi_t2'),
Integer(10, 40, name='roi_t3'),
Real(0.01, 0.04, name='roi_p1'),
Real(0.01, 0.07, name='roi_p2'),
Real(0.01, 0.20, name='roi_p3'),
]
@staticmethod
def stoploss_space() -> List[Dimension]:
"""
Stoploss search space
"""
return [
Real(-0.5, -0.02, name='stoploss'),
]
@staticmethod
def indicator_space() -> Dict[str, Any]:
"""
Define your Hyperopt space for searching strategy parameters
"""
2018-06-19 06:09:54 +00:00
return [
Integer(10, 25, name='mfi-value'),
Integer(15, 45, name='fastd-value'),
Integer(20, 50, name='adx-value'),
Integer(20, 40, name='rsi-value'),
Categorical([True, False], name='mfi-enabled'),
Categorical([True, False], name='fastd-enabled'),
Categorical([True, False], name='adx-enabled'),
Categorical([True, False], name='rsi-enabled'),
]
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
"""
if space in self.config['spaces'] or 'all' in self.config['spaces']:
return True
return False
def hyperopt_space(self) -> List[Dimension]:
"""
Return the space to use during Hyperopt
"""
spaces: List[Dimension] = []
if self.has_space('buy'):
spaces += Hyperopt.indicator_space()
if self.has_space('roi'):
spaces += Hyperopt.roi_space()
if self.has_space('stoploss'):
spaces += Hyperopt.stoploss_space()
return spaces
2017-12-26 08:08:10 +00:00
@staticmethod
def buy_strategy_generator(params: Dict[str, Any]) -> Callable:
"""
Define the buy strategy parameters to be used by hyperopt
"""
def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
2018-03-02 15:22:00 +00:00
"""
Buy strategy Hyperopt will build and use
"""
conditions = []
# GUARDS AND TRENDS
2018-06-19 06:09:54 +00:00
# if 'macd_below_zero' in params and params['macd_below_zero']['enabled']:
# conditions.append(dataframe['macd'] < 0)
if 'mfi-enabled' in params and params['mfi-enabled']:
conditions.append(dataframe['mfi'] < params['mfi-value'])
if 'fastd' in params and params['fastd-enabled']:
conditions.append(dataframe['fastd'] < params['fastd-value'])
if 'adx' in params and params['adx-enabled']:
conditions.append(dataframe['adx'] > params['adx-value'])
if 'rsi' in params and params['rsi-enabled']:
conditions.append(dataframe['rsi'] < params['rsi-value'])
# TRIGGERS
triggers = {
}
2018-06-18 19:40:36 +00:00
#conditions.append(triggers.get(params['trigger']['type']))
conditions.append(dataframe['close'] < dataframe['bb_lowerband']) # single trigger
dataframe.loc[
reduce(lambda x, y: x & y, conditions),
'buy'] = 1
return dataframe
return populate_buy_trend
2018-06-19 06:09:54 +00:00
def generate_optimizer(self, _params) -> Dict:
params = self.get_args(_params)
if self.has_space('roi'):
self.analyze.strategy.minimal_roi = self.generate_roi_table(params)
if self.has_space('buy'):
self.populate_buy_trend = self.buy_strategy_generator(params)
if self.has_space('stoploss'):
self.analyze.strategy.stoploss = params['stoploss']
results = self.backtest(
{
'stake_amount': self.config['stake_amount'],
'processed': self.processed,
'realistic': self.config.get('realistic_simulation', False),
}
)
result_explanation = self.format_results(results)
total_profit = results.profit_percent.sum()
trade_count = len(results.index)
trade_duration = results.trade_duration.mean()
loss = self.calculate_loss(total_profit, trade_count, trade_duration)
2018-06-19 18:57:42 +00:00
return {
'loss': loss,
'status': STATUS_OK,
'result': result_explanation,
}
def format_results(self, results: DataFrame) -> str:
"""
Return the format result in a string
"""
return ('{:6d} trades. Avg profit {: 5.2f}%. '
'Total profit {: 11.8f} {} ({:.4f}Σ%). Avg duration {:5.1f} mins.').format(
len(results.index),
results.profit_percent.mean() * 100.0,
results.profit_abs.sum(),
self.config['stake_currency'],
results.profit_percent.sum(),
results.trade_duration.mean(),
)
2018-03-17 21:43:36 +00:00
def start(self) -> None:
2018-06-02 11:59:35 +00:00
timerange = Arguments.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(
2018-06-02 11:43:51 +00:00
datadir=str(self.config.get('datadir')),
pairs=self.config['exchange']['pair_whitelist'],
ticker_interval=self.ticker_interval,
timerange=timerange
)
if self.has_space('buy'):
2018-05-31 20:00:46 +00:00
self.analyze.populate_indicators = Hyperopt.populate_indicators # type: ignore
self.processed = self.tickerdata_to_dataframe(data)
2018-06-15 07:59:09 +00:00
logger.info('Preparing Trials..')
signal.signal(signal.SIGINT, self.signal_handler)
# read trials file if we have one
if os.path.exists(self.trials_file) and os.path.getsize(self.trials_file) > 0:
self.trials = self.read_trials()
2018-06-15 07:59:09 +00:00
self.current_tries = len(self.trials.results)
self.total_tries += self.current_tries
logger.info(
'Continuing with trials. Current: %d, Total: %d',
self.current_tries,
self.total_tries
)
2018-06-21 11:59:36 +00:00
# results = sorted(self.trials.results, key=itemgetter('loss'))
# best_result = results[0]['result']
cpus = multiprocessing.cpu_count()
print(f'Found {cpus}. Let\'s make them scream!')
opt = Optimizer(
self.hyperopt_space(),
base_estimator="ET",
acq_optimizer="auto",
n_initial_points=30,
acq_optimizer_kwargs={'n_jobs': -1}
)
with Parallel(n_jobs=-1) as parallel:
for i in range(self.total_tries//cpus):
asked = opt.ask(n_points=cpus)
f_val = parallel(delayed(self.generate_optimizer)(v) for v in asked)
opt.tell(asked, [i['loss'] for i in f_val])
for j in range(cpus):
self.log_results(
{
'loss': f_val[j]['loss'],
'current_tries': i * cpus + j,
'total_tries': self.total_tries,
'result': f_val[j]['result'],
}
)
2017-11-25 00:12:44 +00:00
# Improve best parameter logging display
2018-06-19 06:09:54 +00:00
# if best_parameters:
# best_parameters = space_eval(
# self.hyperopt_space(),
# best_parameters
# )
2017-10-30 23:36:35 +00:00
2018-06-19 06:09:54 +00:00
# logger.info('Best parameters:\n%s', json.dumps(best_parameters, indent=4))
# if 'roi_t1' in best_parameters:
# logger.info('ROI table:\n%s', self.generate_roi_table(best_parameters))
2018-01-08 01:45:31 +00:00
2018-06-19 06:09:54 +00:00
# logger.info('Best Result:\n%s', best_result)
2018-01-08 01:45:31 +00:00
2018-06-19 06:09:54 +00:00
# # Store trials result to file to resume next time
# self.save_trials()
2018-03-17 21:43:36 +00:00
def signal_handler(self, sig, frame) -> None:
"""
Hyperopt SIGINT handler
"""
2018-03-25 19:37:14 +00:00
logger.info(
2018-03-02 15:22:00 +00:00
'Hyperopt received %s',
signal.Signals(sig).name
)
self.save_trials()
self.log_trials_result()
sys.exit(0)
2018-03-17 21:43:36 +00:00
def start(args: Namespace) -> None:
"""
Start Backtesting script
:param args: Cli args from Arguments()
:return: None
"""
# Remove noisy log messages
logging.getLogger('hyperopt.tpe').setLevel(logging.WARNING)
# Initialize configuration
2018-03-02 15:22:00 +00:00
# Monkey patch the configuration with hyperopt_conf.py
configuration = Configuration(args)
2018-03-25 19:41:25 +00:00
logger.info('Starting freqtrade in Hyperopt mode')
2018-06-15 07:45:19 +00:00
config = configuration.load_config()
2018-03-25 19:41:25 +00:00
config['exchange']['key'] = ''
config['exchange']['secret'] = ''
# Initialize backtesting object
hyperopt = Hyperopt(config)
hyperopt.start()