def optimize_code(params): from lib.RLTrader import RLTrader trader = RLTrader(**params) trader.optimize() return ""
def run_optimize(args, logger): from lib.RLTrader import RLTrader trader = RLTrader(**vars(args), logger=logger, reward_strategy=reward_strategy) trader.optimize(n_trials=args.trials)
def test_that_args_get_injected_correctly(self, data_mock, opt_mock, init_mock): args = self.parser.parse_args(['optimize']) sut = RLTrader(**vars(args), logger=MagicMock()) sut.study_name = 'test' with mock.patch('lib.util.logger.init_logger'): assert (sut.tensorboard_path == args.tensorboard_path) assert (sut.params_db_path == args.params_db_path) assert (sut.model_verbose == args.model_verbose) assert (sut.nminibatches == args.nminibatches) assert (sut.train_split_percentage == args.train_split_percentage) assert (sut.input_data_path == args.input_data_path) assert (sut.model_verbose == args.model_verbose)
import numpy as np from lib.RLTrader import RLTrader from lib.TraderArgs import TraderArgs from lib.util.logger import init_logger np.warnings.filterwarnings('ignore') option_parser = TraderArgs() args = option_parser.get_args() if __name__ == '__main__': logger = init_logger(__name__, show_debug=args.debug) trader = RLTrader(**vars(args), logger=logger) if args.command == 'optimize': trader.optimize(n_trials=args.trials, n_parallel_jobs=args.parallel_jobs) elif args.command == 'train': trader.train(n_epochs=args.epochs) elif args.command == 'test': trader.test(model_epoch=args.model_epoch, should_render=args.no_render) elif args.command == 'opt-train-test': trader.optimize(args.trials, args.parallel_jobs) trader.train(n_epochs=args.train_epochs, test_trained_model=args.no_test, render_trained_model=args.no_render)
import os import numpy as np from multiprocessing import Pool np.warnings.filterwarnings('ignore') def optimize_code(params): from lib.RLTrader import RLTrader trader = RLTrader(**params) trader.optimize() if __name__ == '__main__': n_processes = os.cpu_count() params = {'n_envs': n_processes} opt_pool = Pool(processes=n_processes) opt_pool.map(optimize_code, [params for _ in range(n_processes)]) from lib.RLTrader import RLTrader trader = RLTrader(**params) trader.train(test_trained_model=True, render_trained_model=True)
np.warnings.filterwarnings('ignore') trader_cli = RLTraderCLI() args = trader_cli.get_args() rewards = { "incremental-profit": IncrementalProfit, "weighted-unrealized-profit": WeightedUnrealizedProfit } reward_strategy = rewards[args.reward_strat] if __name__ == '__main__': logger = init_logger(__name__, show_debug=args.debug) from lib.RLTrader import RLTrader trader = RLTrader(**vars(args), logger=logger, reward_strategy=reward_strategy) if args.command == 'train': trader.train(n_epochs=args.epochs, save_every=args.save_every, test_trained_model=args.test_trained, render_test_env=args.render_test, render_report=args.render_report, save_report=args.save_report) elif args.command == 'test': trader.test(model_epoch=args.model_epoch, render_env=args.render_env, render_report=args.render_report, save_report=args.save_report) elif args.command == 'update-static-data':
import numpy as np from lib.RLTrader import RLTrader np.warnings.filterwarnings('ignore') if __name__ == '__main__': trader = RLTrader() trader.optimize() trader.train(test_trained_model=True, render_trained_model=True)
def optimize_code(params): trader = RLTrader(**params) trader.optimize()
import multiprocessing from lib.RLTrader import RLTrader np.warnings.filterwarnings('ignore') def optimize_code(params): trader = RLTrader(**params) trader.optimize() if __name__ == '__main__': n_process = multiprocessing.cpu_count() params = {'n_cpu': n_process} # processes = [] # for i in range(n_process): # processes.append(multiprocessing.Process(target=optimize_code, args=(params,))) # for p in processes: # p.start() # for p in processes: # p.join() trader = RLTrader(**params) # trader.train(test_trained_model=True, render_trained_model=True) trader.test(model_epoch=10)
def optimize_code(params): from lib.RLTrader import RLTrader trader = RLTrader(**params) trader.optimize() return "" if __name__ == '__main__': n_processes = multiprocessing.cpu_count() params = { 'n_envs': n_processes, 'reward_strategy': WeightedUnrealizedProfit } opt_pool = Pool(processes=n_processes) results = opt_pool.imap(optimize_code, [params for _ in range(n_processes)]) # print([result.get() for result in results]) from lib.RLTrader import RLTrader trader = RLTrader(**params) trader.train(test_trained_model=True, render_test_env=True, render_report=True, save_report=True)
def run_optimize(args, logger): from lib.RLTrader import RLTrader trader = RLTrader(**vars(args), logger=logger) trader.optimize(args.trials)
trader = RLTrader(**vars(args), logger=logger) trader.optimize(args.trials) if __name__ == '__main__': logger = init_logger(__name__, show_debug=args.debug) if args.command == 'optimize': n_processes = args.parallel_jobs processes = [] for _ in range(n_processes): processes.append(Process(target=run_optimize, args=(args, logger))) for proc in processes: proc.start() for proc in processes: proc.join() from lib.RLTrader import RLTrader trader = RLTrader(**vars(args), logger=logger) if args.command == 'train': trader.train(n_epochs=args.epochs) elif args.command == 'test': trader.test(model_epoch=args.model_epoch, should_render=args.no_render) elif args.command == 'update-static-data': download_data_async()
import numpy as np from lib.RLTrader import RLTrader np.warnings.filterwarnings('ignore') if __name__ == '__main__': trader = RLTrader() #trader.optimize(n_trials=1) trader.train(n_epochs=10, test_trained_model=True, render_trained_model=True) # trader.test()
def run_concurrent_optimize(trader: RLTrader, args): trader.optimize(args.trials, args.trials, args.parallel_jobs)
def run_concurrent_optimize(): trader = RLTrader(**vars(args)) trader.optimize(args.trials)