""" IHyperOpt interface This module defines the interface to apply for hyperopts """ import logging import math from abc import ABC, abstractmethod from typing import Dict, Any, Callable, List from pandas import DataFrame from skopt.space import Dimension, Integer, Real from freqtrade.exchange import timeframe_to_minutes from freqtrade.misc import round_dict logger = logging.getLogger(__name__) class IHyperOpt(ABC): """ Interface for freqtrade hyperopts Defines the mandatory structure must follow any custom hyperopts Class attributes you can use: ticker_interval -> int: value of the ticker interval to use for the strategy """ ticker_interval: str @staticmethod @abstractmethod def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame: """ Populate indicators that will be used in the Buy and Sell strategy. :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe(). :return: A Dataframe with all mandatory indicators for the strategies. """ @staticmethod @abstractmethod def buy_strategy_generator(params: Dict[str, Any]) -> Callable: """ Create a buy strategy generator. """ @staticmethod @abstractmethod def sell_strategy_generator(params: Dict[str, Any]) -> Callable: """ Create a sell strategy generator. """ @staticmethod @abstractmethod def indicator_space() -> List[Dimension]: """ Create an indicator space. """ @staticmethod @abstractmethod def sell_indicator_space() -> List[Dimension]: """ Create a sell indicator space. """ @staticmethod def generate_roi_table(params: Dict) -> Dict[int, float]: """ Create a ROI table. Generates the ROI table that will be used by Hyperopt. You may override it in your custom Hyperopt class. """ 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]: """ Create a ROI space. Defines values to search for each ROI steps. This method implements adaptive roi hyperspace with varied ranges for parameters which automatically adapts to the ticker interval used. It's used by Freqtrade by default, if no custom roi_space method is defined. """ # Default scaling coefficients for the roi hyperspace. Can be changed # to adjust resulting ranges of the ROI tables. # Increase if you need wider ranges in the roi hyperspace, decrease if shorter # ranges are needed. roi_t_alpha = 1.0 roi_p_alpha = 1.0 ticker_interval_mins = timeframe_to_minutes(IHyperOpt.ticker_interval) # We define here limits for the ROI space parameters automagically adapted to the # ticker_interval used by the bot: # # * 'roi_t' (limits for the time intervals in the ROI tables) components # are scaled linearly. # * 'roi_p' (limits for the ROI value steps) components are scaled logarithmically. # # The scaling is designed so that it maps exactly to the legacy Freqtrade roi_space() # method for the 5m ticker interval. roi_t_scale = ticker_interval_mins / 5 roi_p_scale = math.log1p(ticker_interval_mins) / math.log1p(5) roi_limits = { 'roi_t1_min': int(10 * roi_t_scale * roi_t_alpha), 'roi_t1_max': int(120 * roi_t_scale * roi_t_alpha), 'roi_t2_min': int(10 * roi_t_scale * roi_t_alpha), 'roi_t2_max': int(60 * roi_t_scale * roi_t_alpha), 'roi_t3_min': int(10 * roi_t_scale * roi_t_alpha), 'roi_t3_max': int(40 * roi_t_scale * roi_t_alpha), 'roi_p1_min': 0.01 * roi_p_scale * roi_p_alpha, 'roi_p1_max': 0.04 * roi_p_scale * roi_p_alpha, 'roi_p2_min': 0.01 * roi_p_scale * roi_p_alpha, 'roi_p2_max': 0.07 * roi_p_scale * roi_p_alpha, 'roi_p3_min': 0.01 * roi_p_scale * roi_p_alpha, 'roi_p3_max': 0.20 * roi_p_scale * roi_p_alpha, } logger.debug(f"Using roi space limits: {round_dict(roi_limits, 5)}") p = { 'roi_t1': roi_limits['roi_t1_min'], 'roi_t2': roi_limits['roi_t2_min'], 'roi_t3': roi_limits['roi_t3_min'], 'roi_p1': roi_limits['roi_p1_min'], 'roi_p2': roi_limits['roi_p2_min'], 'roi_p3': roi_limits['roi_p3_min'], } logger.info(f"Min roi table: {round_dict(IHyperOpt.generate_roi_table(p), 5)}") p = { 'roi_t1': roi_limits['roi_t1_max'], 'roi_t2': roi_limits['roi_t2_max'], 'roi_t3': roi_limits['roi_t3_max'], 'roi_p1': roi_limits['roi_p1_max'], 'roi_p2': roi_limits['roi_p2_max'], 'roi_p3': roi_limits['roi_p3_max'], } logger.info(f"Max roi table: {round_dict(IHyperOpt.generate_roi_table(p), 5)}") return [ Integer(roi_limits['roi_t1_min'], roi_limits['roi_t1_max'], name='roi_t1'), Integer(roi_limits['roi_t2_min'], roi_limits['roi_t2_max'], name='roi_t2'), Integer(roi_limits['roi_t3_min'], roi_limits['roi_t3_max'], name='roi_t3'), Real(roi_limits['roi_p1_min'], roi_limits['roi_p1_max'], name='roi_p1'), Real(roi_limits['roi_p2_min'], roi_limits['roi_p2_max'], name='roi_p2'), Real(roi_limits['roi_p3_min'], roi_limits['roi_p3_max'], name='roi_p3'), ] @staticmethod def stoploss_space() -> List[Dimension]: """ Create a stoploss space. Defines range of stoploss values to search. You may override it in your custom Hyperopt class. """ return [ Real(-0.5, -0.02, name='stoploss'), ] # This is needed for proper unpickling the class attribute ticker_interval # which is set to the actual value by the resolver. # Why do I still need such shamanic mantras in modern python? def __getstate__(self): state = self.__dict__.copy() state['ticker_interval'] = self.ticker_interval return state def __setstate__(self, state): self.__dict__.update(state) IHyperOpt.ticker_interval = state['ticker_interval']