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()
