def __init__(self, training_candles: ndarray, testing_candles: ndarray, optimal_total: int, cpu_cores: int, csv: bool, json: bool, start_date: str, finish_date: str) -> None: if len(router.routes) != 1: raise NotImplementedError('optimize_mode mode only supports one route at the moment') self.strategy_name = router.routes[0].strategy_name self.optimal_total = optimal_total self.exchange = router.routes[0].exchange self.symbol = router.routes[0].symbol self.timeframe = router.routes[0].timeframe StrategyClass = jh.get_strategy_class(self.strategy_name) self.strategy_hp = StrategyClass.hyperparameters(None) solution_len = len(self.strategy_hp) if solution_len == 0: raise exceptions.InvalidStrategy('Targeted strategy does not implement a valid hyperparameters() method.') super().__init__( iterations=2000 * solution_len, population_size=solution_len * 100, solution_len=solution_len, options={ 'strategy_name': self.strategy_name, 'exchange': self.exchange, 'symbol': self.symbol, 'timeframe': self.timeframe, 'strategy_hp': self.strategy_hp, 'csv': csv, 'json': json, 'start_date': start_date, 'finish_date': finish_date, } ) if cpu_cores > cpu_count(): raise ValueError(f'Entered cpu cores number is more than available on this machine which is {cpu_count()}') elif cpu_cores == 0: self.cpu_cores = cpu_count() else: self.cpu_cores = cpu_cores self.training_candles = training_candles self.testing_candles = testing_candles key = jh.key(self.exchange, self.symbol) training_candles_start_date = jh.timestamp_to_time(self.training_candles[key]['candles'][0][0]).split('T')[0] training_candles_finish_date = jh.timestamp_to_time(self.training_candles[key]['candles'][-1][0]).split('T')[0] testing_candles_start_date = jh.timestamp_to_time(self.testing_candles[key]['candles'][0][0]).split('T')[0] testing_candles_finish_date = jh.timestamp_to_time(self.testing_candles[key]['candles'][-1][0]).split('T')[0] self.training_initial_candles = [] self.testing_initial_candles = [] for c in config['app']['considering_candles']: self.training_initial_candles.append( required_candles.load_required_candles(c[0], c[1], training_candles_start_date, training_candles_finish_date)) self.testing_initial_candles.append( required_candles.load_required_candles(c[0], c[1], testing_candles_start_date, testing_candles_finish_date))
def __init__(self, training_candles, testing_candles, optimal_total): if len(router.routes) != 1: raise NotImplementedError( 'optimize_mode mode only supports one route at the moment') self.strategy_name = router.routes[0].strategy_name self.optimal_total = optimal_total self.exchange = router.routes[0].exchange self.symbol = router.routes[0].symbol self.timeframe = router.routes[0].timeframe StrategyClass = jh.get_strategy_class(self.strategy_name) self.strategy_hp = StrategyClass.hyperparameters(None) solution_len = len(self.strategy_hp) if solution_len == 0: raise exceptions.InvalidStrategy( 'Targeted strategy does not implement a valid hyperparameters() method.' ) super().__init__(iterations=2000 * solution_len, population_size=solution_len * 100, solution_len=solution_len, options={ 'strategy_name': self.strategy_name, 'exchange': self.exchange, 'symbol': self.symbol, 'timeframe': self.timeframe }) self.training_candles = training_candles self.testing_candles = testing_candles key = jh.key(self.exchange, self.symbol) training_candles_start_date = jh.timestamp_to_time( self.training_candles[key]['candles'][0][0]).split('T')[0] training_candles_finish_date = jh.timestamp_to_time( self.training_candles[key]['candles'][-1][0]).split('T')[0] testing_candles_start_date = jh.timestamp_to_time( self.testing_candles[key]['candles'][0][0]).split('T')[0] testing_candles_finish_date = jh.timestamp_to_time( self.testing_candles[key]['candles'][-1][0]).split('T')[0] self.training_initial_candles = [] self.testing_initial_candles = [] for c in config['app']['considering_candles']: self.training_initial_candles.append( required_candles.load_required_candles( c[0], c[1], training_candles_start_date, training_candles_finish_date)) self.testing_initial_candles.append( required_candles.load_required_candles( c[0], c[1], testing_candles_start_date, testing_candles_finish_date))
def __init__(self, training_candles, testing_candles): if len(router.routes) != 1: raise NotImplementedError( 'optimize_mode mode only supports one route at the moment') self.strategy_name = router.routes[0].strategy_name self.exchange = router.routes[0].exchange self.symbol = router.routes[0].symbol self.timeframe = router.routes[0].timeframe StrategyClass = jh.get_strategy_class(self.strategy_name) self.strategy_hp = StrategyClass.hyper_parameters() solution_len = len(self.strategy_hp) if solution_len == 0: raise InvalidStrategy( 'Targeted strategy does not implement a valid hyper_parameters() method.' ) super().__init__(iterations=2000 * solution_len, population_size=solution_len * 100, solution_len=solution_len, options={ 'strategy_name': self.strategy_name, 'exchange': self.exchange, 'symbol': self.symbol, 'timeframe': self.timeframe }) self.training_candles = training_candles self.testing_candles = testing_candles key = jh.key(self.exchange, self.symbol) # training self.required_initial_training_candles = required_candles.load_required_candles( self.exchange, self.symbol, jh.timestamp_to_time(self.training_candles[key]['candles'][0][0]), jh.timestamp_to_time(self.training_candles[key]['candles'][-1][0])) # testing self.required_initial_testing_candles = required_candles.load_required_candles( self.exchange, self.symbol, jh.timestamp_to_time(self.testing_candles[key]['candles'][0][0]), jh.timestamp_to_time(self.testing_candles[key]['candles'][-1][0]))
def load_candles( start_date_str: str, finish_date_str: str) -> Dict[str, Dict[str, Union[str, np.ndarray]]]: start_date = jh.date_to_timestamp(start_date_str) finish_date = jh.date_to_timestamp(finish_date_str) - 60000 # validate if start_date == finish_date: raise ValueError('start_date and finish_date cannot be the same.') if start_date > finish_date: raise ValueError('start_date cannot be bigger than finish_date.') if finish_date > arrow.utcnow().int_timestamp * 1000: raise ValueError("Can't load candle data from the future!") # load and add required warm-up candles for backtest if jh.is_backtesting(): for c in config['app']['considering_candles']: required_candles.inject_required_candles_to_store( required_candles.load_required_candles(c[0], c[1], start_date_str, finish_date_str), c[0], c[1]) # download candles for the duration of the backtest candles = {} for c in config['app']['considering_candles']: exchange, symbol = c[0], c[1] key = jh.key(exchange, symbol) cache_key = '{}-{}-'.format(start_date_str, finish_date_str) + key cached_value = cache.get_value(cache_key) # if cache exists if cached_value: candles_tuple = cached_value # not cached, get and cache for later calls in the next 5 minutes else: # fetch from database candles_tuple = Candle.select( Candle.timestamp, Candle.open, Candle.close, Candle.high, Candle.low, Candle.volume).where( Candle.timestamp.between(start_date, finish_date), Candle.exchange == exchange, Candle.symbol == symbol).order_by( Candle.timestamp.asc()).tuples() # validate that there are enough candles for selected period required_candles_count = (finish_date - start_date) / 60_000 if len(candles_tuple) == 0 or candles_tuple[-1][ 0] != finish_date or candles_tuple[0][0] != start_date: raise exceptions.CandleNotFoundInDatabase( 'Not enough candles for {}. Try running "jesse import-candles"' .format(symbol)) elif len(candles_tuple) != required_candles_count + 1: raise exceptions.CandleNotFoundInDatabase( 'There are missing candles between {} => {}'.format( start_date_str, finish_date_str)) # cache it for near future calls cache.set_value(cache_key, tuple(candles_tuple), expire_seconds=60 * 60 * 24 * 7) candles[key] = { 'exchange': exchange, 'symbol': symbol, 'candles': np.array(candles_tuple) } return candles