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 run(dna=False): """ :param dna: """ # # # # # # # # # # # # # # # # # # # # # # # # # trading routes # # # # # # # # # # # # # # # # # # # # # # # # arr = [] if not dna: print( jh.color('{}{}{}'.format('#' * 25, ' Trading Routes ', '#' * 25), 'blue')) arr.append(('exchange', 'symbol', 'timeframe', 'strategy name', 'DNA')) else: print(jh.color('Translated DNAs into hyper-parameters:', 'blue')) translated_DNAs_count = 0 for i, r in enumerate(router.routes): if dna and r.dna: translated_DNAs_count += 1 StrategyClass = jh.get_strategy_class(r.strategy_name) hyper_parameters = jh.dna_to_hp(StrategyClass.hyper_parameters(), r.dna) table.key_value(hyper_parameters.items(), r.strategy_name, uppercase_title=False) print('\n') else: arr.append( [r.exchange, r.symbol, r.timeframe, r.strategy_name, r.dna]) if not dna: table.multi_value(arr) print('\n') else: if not translated_DNAs_count: print('No DNA string found.') # # # # # # # # # # # # # # # # # # # # # # # # # extra_candles # # # # # # # # # # # # # # # # # # # # # # # # if not dna: print( jh.color('{}{}{}'.format('#' * 25, ' Extra Candles ', '#' * 25), 'blue')) arr = [('exchange', 'symbol', 'timeframe')] for i, r in enumerate(router.extra_candles): arr.append([r[0], r[1], r[2]]) table.multi_value(arr) print('\n')
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 simulator(candles: Dict[str, Dict[str, Union[str, np.ndarray]]], hyperparameters=None) -> None: begin_time_track = time.time() key = '{}-{}'.format(config['app']['considering_candles'][0][0], config['app']['considering_candles'][0][1]) first_candles_set = candles[key]['candles'] length = len(first_candles_set) # to preset the array size for performance store.app.starting_time = first_candles_set[0][0] store.app.time = first_candles_set[0][0] # initiate strategies for r in router.routes: StrategyClass = jh.get_strategy_class(r.strategy_name) try: r.strategy = StrategyClass() except TypeError: raise exceptions.InvalidStrategy( "Looks like the structure of your strategy directory is incorrect. Make sure to include the strategy INSIDE the __init__.py file." "\nIf you need working examples, check out: https://github.com/jesse-ai/example-strategies" ) except: raise r.strategy.name = r.strategy_name r.strategy.exchange = r.exchange r.strategy.symbol = r.symbol r.strategy.timeframe = r.timeframe # inject hyper parameters (used for optimize_mode) # convert DNS string into hyperparameters if r.dna and hyperparameters is None: hyperparameters = jh.dna_to_hp(r.strategy.hyperparameters(), r.dna) # inject hyperparameters sent within the optimize mode if hyperparameters is not None: r.strategy.hp = hyperparameters # init few objects that couldn't be initiated in Strategy __init__ # it also injects hyperparameters into self.hp in case the route does not uses any DNAs r.strategy._init_objects() selectors.get_position(r.exchange, r.symbol).strategy = r.strategy # add initial balance save_daily_portfolio_balance() with click.progressbar(length=length, label='Executing simulation...') as progressbar: for i in range(length): # update time store.app.time = first_candles_set[i][0] + 60_000 # add candles for j in candles: short_candle = candles[j]['candles'][i] if i != 0: previous_short_candle = candles[j]['candles'][i - 1] short_candle = _get_fixed_jumped_candle( previous_short_candle, short_candle) exchange = candles[j]['exchange'] symbol = candles[j]['symbol'] store.candles.add_candle(short_candle, exchange, symbol, '1m', with_execution=False, with_generation=False) # print short candle if jh.is_debuggable('shorter_period_candles'): print_candle(short_candle, True, symbol) _simulate_price_change_effect(short_candle, exchange, symbol) # generate and add candles for bigger timeframes for timeframe in config['app']['considering_timeframes']: # for 1m, no work is needed if timeframe == '1m': continue count = jh.timeframe_to_one_minutes(timeframe) until = count - ((i + 1) % count) if (i + 1) % count == 0: generated_candle = generate_candle_from_one_minutes( timeframe, candles[j]['candles'][(i - (count - 1)):(i + 1)]) store.candles.add_candle(generated_candle, exchange, symbol, timeframe, with_execution=False, with_generation=False) # update progressbar if not jh.is_debugging() and not jh.should_execute_silently( ) and i % 60 == 0: progressbar.update(60) # now that all new generated candles are ready, execute for r in router.routes: count = jh.timeframe_to_one_minutes(r.timeframe) # 1m timeframe if r.timeframe == timeframes.MINUTE_1: r.strategy._execute() elif (i + 1) % count == 0: # print candle if jh.is_debuggable('trading_candles'): print_candle( store.candles.get_current_candle( r.exchange, r.symbol, r.timeframe), False, r.symbol) r.strategy._execute() # now check to see if there's any MARKET orders waiting to be executed store.orders.execute_pending_market_orders() if i != 0 and i % 1440 == 0: save_daily_portfolio_balance() if not jh.should_execute_silently(): if jh.is_debuggable('trading_candles') or jh.is_debuggable( 'shorter_period_candles'): print('\n') # print executed time for the backtest session finish_time_track = time.time() print( 'Executed backtest simulation in: ', '{} seconds'.format(round(finish_time_track - begin_time_track, 2))) for r in router.routes: r.strategy._terminate() store.orders.execute_pending_market_orders() # now that backtest is finished, add finishing balance save_daily_portfolio_balance()
def simulator( candles: dict, run_silently: bool, hyperparameters: dict = None ) -> None: begin_time_track = time.time() key = f"{config['app']['considering_candles'][0][0]}-{config['app']['considering_candles'][0][1]}" first_candles_set = candles[key]['candles'] length = len(first_candles_set) # to preset the array size for performance try: store.app.starting_time = first_candles_set[0][0] except IndexError: raise IndexError('Check your "warm_up_candles" config value') store.app.time = first_candles_set[0][0] # initiate strategies for r in router.routes: # if the r.strategy is str read it from file if isinstance(r.strategy_name, str): StrategyClass = jh.get_strategy_class(r.strategy_name) # else it is a class object so just use it else: StrategyClass = r.strategy_name try: r.strategy = StrategyClass() except TypeError: raise exceptions.InvalidStrategy( "Looks like the structure of your strategy directory is incorrect. Make sure to include the strategy INSIDE the __init__.py file." "\nIf you need working examples, check out: https://github.com/jesse-ai/example-strategies" ) except: raise r.strategy.name = r.strategy_name r.strategy.exchange = r.exchange r.strategy.symbol = r.symbol r.strategy.timeframe = r.timeframe # read the dna from strategy's dna() and use it for injecting inject hyperparameters # first convert DNS string into hyperparameters if len(r.strategy.dna()) > 0 and hyperparameters is None: hyperparameters = jh.dna_to_hp(r.strategy.hyperparameters(), r.strategy.dna()) # inject hyperparameters sent within the optimize mode if hyperparameters is not None: r.strategy.hp = hyperparameters # init few objects that couldn't be initiated in Strategy __init__ # it also injects hyperparameters into self.hp in case the route does not uses any DNAs r.strategy._init_objects() selectors.get_position(r.exchange, r.symbol).strategy = r.strategy # add initial balance save_daily_portfolio_balance() progressbar = Progressbar(length, step=60) for i in range(length): # update time store.app.time = first_candles_set[i][0] + 60_000 # add candles for j in candles: short_candle = candles[j]['candles'][i] if i != 0: previous_short_candle = candles[j]['candles'][i - 1] short_candle = _get_fixed_jumped_candle(previous_short_candle, short_candle) exchange = candles[j]['exchange'] symbol = candles[j]['symbol'] store.candles.add_candle(short_candle, exchange, symbol, '1m', with_execution=False, with_generation=False) # print short candle if jh.is_debuggable('shorter_period_candles'): print_candle(short_candle, True, symbol) _simulate_price_change_effect(short_candle, exchange, symbol) # generate and add candles for bigger timeframes for timeframe in config['app']['considering_timeframes']: # for 1m, no work is needed if timeframe == '1m': continue count = jh.timeframe_to_one_minutes(timeframe) # until = count - ((i + 1) % count) if (i + 1) % count == 0: generated_candle = generate_candle_from_one_minutes( timeframe, candles[j]['candles'][(i - (count - 1)):(i + 1)]) store.candles.add_candle(generated_candle, exchange, symbol, timeframe, with_execution=False, with_generation=False) # update progressbar if not run_silently and i % 60 == 0: progressbar.update() sync_publish('progressbar', { 'current': progressbar.current, 'estimated_remaining_seconds': progressbar.estimated_remaining_seconds }) # now that all new generated candles are ready, execute for r in router.routes: count = jh.timeframe_to_one_minutes(r.timeframe) # 1m timeframe if r.timeframe == timeframes.MINUTE_1: r.strategy._execute() elif (i + 1) % count == 0: # print candle if jh.is_debuggable('trading_candles'): print_candle(store.candles.get_current_candle(r.exchange, r.symbol, r.timeframe), False, r.symbol) r.strategy._execute() # now check to see if there's any MARKET orders waiting to be executed store.orders.execute_pending_market_orders() if i != 0 and i % 1440 == 0: save_daily_portfolio_balance() if not run_silently: # print executed time for the backtest session finish_time_track = time.time() sync_publish('alert', { 'message': f'Successfully executed backtest simulation in: {round(finish_time_track - begin_time_track, 2)} seconds', 'type': 'success' }) for r in router.routes: r.strategy._terminate() store.orders.execute_pending_market_orders() # now that backtest is finished, add finishing balance save_daily_portfolio_balance()
def test_get_strategy_class(): from jesse.strategies import Strategy assert issubclass(jh.get_strategy_class("Test01"), Strategy)
def __init__( self, training_candles: ndarray, testing_candles: ndarray, optimal_total: int, cpu_cores: int, csv: bool, export_json: bool, start_date: str, finish_date: str, charset: str = r'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw', fitness_goal: float = 1, ) -> 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.exchange = router.routes[0].exchange self.symbol = router.routes[0].symbol self.timeframe = router.routes[0].timeframe strategy_class = jh.get_strategy_class(self.strategy_name) self.strategy_hp = strategy_class.hyperparameters(None) solution_len = len(self.strategy_hp) if solution_len == 0: raise exceptions.InvalidStrategy('Targeted strategy does not implement a valid hyperparameters() method.') self.started_index = 0 self.start_time = jh.now_to_timestamp() self.population = [] self.iterations = 2000 * solution_len self.population_size = solution_len * 100 self.solution_len = solution_len self.charset = charset self.fitness_goal = fitness_goal self.cpu_cores = 0 self.optimal_total = optimal_total self.training_candles = training_candles self.testing_candles = testing_candles self.average_execution_seconds = 0 # check for termination event once per second tl_0 = Timeloop() @tl_0.job(interval=timedelta(seconds=1)) def check_for_termination(): if process_status() != 'started': raise exceptions.Termination tl_0.start() options = { 'strategy_name': self.strategy_name, 'exchange': self.exchange, 'symbol': self.symbol, 'timeframe': self.timeframe, 'strategy_hp': self.strategy_hp, 'csv': csv, 'json': export_json, 'start_date': start_date, 'finish_date': finish_date, } self.options = {} if options is None else options os.makedirs('./storage/temp/optimize', exist_ok=True) self.temp_path = f"./storage/temp/optimize/{self.options['strategy_name']}-{self.options['exchange']}-{self.options['symbol']}-{self.options['timeframe']}-{self.options['start_date']}-{self.options['finish_date']}.pickle" if fitness_goal > 1 or fitness_goal < 0: raise ValueError('fitness scores must be between 0 and 1') if not optimal_total > 0: raise ValueError('optimal_total must be bigger than 0') # # if temp file exists, load data to resume previous session # if jh.file_exists(self.temp_path) and click.confirm( # 'Previous session detected. Do you want to resume?', default=True # ): # self.load_progress() 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
def simulator(candles, hyper_parameters=None): begin_time_track = time.time() key = '{}-{}'.format(config['app']['trading_exchanges'][0], config['app']['trading_symbols'][0]) first_candles_set = candles[key]['candles'] length = len(first_candles_set) # to preset the array size for performance store.app.starting_time = first_candles_set[0][0] # initiate strategies for r in router.routes: StrategyClass = jh.get_strategy_class(r.strategy_name) # convert DNS string into hyper_parameters if r.dna and hyper_parameters is None: hyper_parameters = jh.dna_to_hp(StrategyClass.hyper_parameters(), r.dna) r.strategy = StrategyClass() r.strategy.name = r.strategy_name r.strategy.exchange = r.exchange r.strategy.symbol = r.symbol r.strategy.timeframe = r.timeframe # init few objects that couldn't be initiated in Strategy __init__ r.strategy._init_objects() # inject hyper parameters (used for optimize_mode) if hyper_parameters is not None: r.strategy.hp = hyper_parameters selectors.get_position(r.exchange, r.symbol).strategy = r.strategy # add initial balance _save_daily_portfolio_balance() with click.progressbar(length=length, label='Executing simulation...') as progressbar: for i in range(length): # update time store.app.time = first_candles_set[i][0] + 60_000 # add candles for j in candles: short_candle = candles[j]['candles'][i] exchange = candles[j]['exchange'] symbol = candles[j]['symbol'] store.candles.add_candle(short_candle, exchange, symbol, '1m', with_execution=False, with_generation=False) # print short candle if jh.is_debuggable('shorter_period_candles'): print_candle(short_candle, True, symbol) _simulate_price_change_effect(short_candle, exchange, symbol) # generate and add candles for bigger timeframes for timeframe in config['app']['considering_timeframes']: # for 1m, no work is needed if timeframe == '1m': continue count = jh.timeframe_to_one_minutes(timeframe) until = count - ((i + 1) % count) if (i + 1) % count == 0: generated_candle = generate_candle_from_one_minutes( timeframe, candles[j]['candles'][(i - (count - 1)):(i + 1)]) store.candles.add_candle(generated_candle, exchange, symbol, timeframe, with_execution=False, with_generation=False) # update progressbar if not jh.is_debugging() and not jh.should_execute_silently( ) and i % 60 == 0: progressbar.update(60) # now that all new generated candles are ready, execute for r in router.routes: count = jh.timeframe_to_one_minutes(r.timeframe) # 1m timeframe if r.timeframe == timeframes.MINUTE_1: r.strategy._execute() elif (i + 1) % count == 0: # print candle if jh.is_debuggable('trading_candles'): print_candle( store.candles.get_current_candle( r.exchange, r.symbol, r.timeframe), False, r.symbol) r.strategy._execute() # now check to see if there's any MARKET orders waiting to be executed store.orders.execute_pending_market_orders() if i != 0 and i % 1440 == 0: _save_daily_portfolio_balance() if not jh.should_execute_silently(): if jh.is_debuggable('trading_candles') or jh.is_debuggable( 'shorter_period_candles'): print('\n') # print executed time for the backtest session finish_time_track = time.time() print( 'Executed backtest simulation in: ', '{} seconds'.format(round(finish_time_track - begin_time_track, 2))) for r in router.routes: r.strategy._terminate() # now that backtest is finished, add finishing balance _save_daily_portfolio_balance()