def inspect(network, loader, path, early_stop=None): network.eval() path += os.path.sep maybe_make_dir(path) progress = tqdm(total=len(loader), dynamic_ncols=True) with progress, torch.no_grad(): for i, args in enumerate(loader): if i == early_stop: break if torch.cuda.is_available(): input = args[0].cuda() directory = path + os.path.sep + str(i) # prediction prediction = network(input) heatmap = torch.sigmoid(prediction) heatmap = heatmap.cpu()[0, 0].numpy() hm_path = directory + os.path.sep + 'heatmap.npy' maybe_make_dir(hm_path, silent=True) np.save(hm_path, heatmap) # image image = input.cpu()[0].numpy().transpose(1, 2, 0) np.save(directory + os.path.sep + 'image.npy', image) # ground truth g_truth = args[-1][0, 0].numpy() np.save(directory + os.path.sep + 'g_truth.npy', g_truth) progress.update(1)
def run_all(): BATCH_SIZE = 300 MAX_ITERS = 10000 FILEPATH = 'EXPERIMENTS_FINAL_LONG' utils.maybe_make_dir(FILEPATH) args = [] #for exp_name, _ in AVAILABLE_EXPERIMENTS.items(): for exp_name in [ 'MonotonicOnlyTheta', 'MonotonicThetaAndSigma', 'MonotonicZeroBudgetEveryStep', 'NoWorseThanBaselineEveryStep', 'ExpBudget_NoDetPolicy', 'ExpBudget_SemiDetPolicy', 'ExpBudget_DetPolicy' ]: for random_seed in [1, 2, 3, 4, 5]: name = exp_name + '_' + str(random_seed) args.append([ exp_name, name, BATCH_SIZE, MAX_ITERS, FILEPATH, random_seed, False, True ]) for exp_name in [ 'SimultaneousThetaAndSigma_half', 'SimultaneousThetaAndSigma_two_thirds_theta', 'SimultaneousThetaAndSigma_two_thirds_sigma' ]: for random_seed in [1, 2, 3, 4, 5]: name = exp_name + '_' + str(random_seed) args.append([ exp_name, name, math.floor(BATCH_SIZE * 2 / 3), MAX_ITERS, FILEPATH, random_seed, False, True ]) p = multiprocessing.Pool() p.starmap(run, args)
os.environ['KMP_DUPLICATE_LIB_OK']='True' if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('-e', '--episode', type=int, default=2000, help='number of episode to run') parser.add_argument('-b', '--batch_size', type=int, default=32, help='batch size for experience replay') parser.add_argument('-i', '--initial_invest', type=int, default=20000, help='initial investment amount') parser.add_argument('-m', '--mode', type=str, required=True, help='either "train" or "test"') parser.add_argument('-w', '--weights', type=str, help='a trained model weights') args = parser.parse_args() maybe_make_dir('weights') maybe_make_dir('portfolio_val') timestamp = time.strftime('%Y%m%d%H%M') data = np.around(get_data()) data_size = data.shape[1] data_cut_point = int(0.75*data_size) train_data = data[:, :data_cut_point] test_data = data[:, data_cut_point:] env = TradingEnv(train_data, args.initial_invest) state_size = env.observation_space.shape action_size = env.action_space.n agent = DQNAgent(state_size, action_size) scaler = get_scaler(env)
index_col=0, names=[ "datetime", "bid", "ask", "open", "high", "low", "close", "avg_price", "volume", "turnover", "trades" ]) eric = eric[eric.index > "2018-01-01"] sand = sand[sand.index > "2018-01-01"] ce = eric["close"].values[::-1] cs = sand["close"].values[::-1] data = np.array([ce, cs]) train_data = data[:, :200] test_data = data[:, 200:] maybe_make_dir("weights") maybe_make_dir("portfolio_val") timestamp = time.strftime("%Y%m%d%H%M") episode = 25 batch_size = 32 runs = {s: [] for s in range(episode)} def sharpe(vals, period=200): vals = np.array(vals) rets = np.diff(vals) / vals[:-1] return np.sqrt(period) * np.mean(rets) / np.std(rets) def main(): env = TradingEnv(train_data)
import re from env import TradingEnv from agent import DQNAgent from utils import get_data, get_scaler, maybe_make_dir if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("-e", "--episode", type=int, default=200, help="number of episode to run") parser.add_argument("-b", "--batch_size", type=int, default = 32, help = "batch size for experience relay") parser.add_argument("-i", "--initial_invest", type=int, default=20000, help="initial investment amount") parser.add_argument("-m", "--mode", type=str, required=True, help='either "train" or "test"') parser.add_argument("-w", "--weights", type=str, help="a trained model weights") args = parser.parse_args() maybe_make_dir('weights') maybe_make_dir("portfolio_val") timestamp = time.strftime("%Y%m%d%H%M") data = np.around(get_data()) train_data = data[:, :3526] test_data = data[:, 3256:] env = TradingEnv(train_data, args.initial_invest) state_size = env.observation_space.shape action_size = env.action_space.n agent = DQNAgent(state_size, action_size) scaler = get_scaler(env) portfolio_value = []
default=100, type=int, help='Specify batch size') parser.add_argument('--max_iters', dest='max_iters', default=2000, type=int, help='Maximum number of iterations') parser.add_argument('--filepath', dest='filepath', default='experiments', type=str, help='Where to save the data') parser.add_argument('--random_seed', dest='random_seed', default=seeding.create_seed(), type=int, help='Random seed') parser.add_argument('--experiment_class', dest='experiment_class', default=list(AVAILABLE_EXPERIMENTS.keys())[0], type=str, help='type of experiment: ' + ', '.join(AVAILABLE_EXPERIMENTS.keys())) args = parser.parse_args() maybe_make_dir(args.filepath) run(**vars(args))
def DqnProgram(args, setResult, training_result): parser = argparse.ArgumentParser() parser.add_argument('-e', '--episode', type=int, default=2000, help='number of episode to run') parser.add_argument('-b', '--batch_size', type=int, default=32, help='batch size for experience replay') parser.add_argument('-i', '--initial_invest', type=int, default=20000, help='initial investment amount') parser.add_argument('-m', '--mode', type=str, required=True, help='either "train" or "test"') parser.add_argument('-w', '--weights', type=str, help='a trained model weights') args = parser.parse_args(args) maybe_make_dir('weights') maybe_make_dir('portfolio_val') import time timestamp = time.strftime('%Y%m%d%H%M') data = get_data(mode=args.mode) # TODO UI의 종목과 연결시키기. data = np.array([c['종가'] for c in data]) env = TradingEnv(data, args.initial_invest) state_size = env.observation_space.shape action_size = env.action_space.shape agent = DQNAgent(state_size, action_size) scaler = get_scaler(env) portfolio_value = [] if not args.weights is None: agent.load(args.weights) timestamp = re.findall(r'\d{12}', args.weights)[0] for e in range(args.episode): state = env.reset() state = scaler.transform([state]) for time in range(env.n_step): action = agent.act(state) next_state, reward, done, info = env.step(action) next_state = scaler.transform([next_state]) if args.mode == 'train': agent.remember(state, action, reward, next_state, done) state = next_state if done: msg = "episode: {}/{}, episode end value: {}".format( e + 1, args.episode, info['cur_val']) print(msg) setResult(msg=msg) training_result.append(info['cur_val']) portfolio_value.append( info['cur_val']) # append episode end portfolio value break if args.mode == 'train' and len(agent.memory) > args.batch_size: agent.replay(args.batch_size) if args.mode == 'train' and (e + 1) % 10 == 0: # checkpoint weights agent.save('weights/{}-dqn.h5'.format(timestamp)) # save portfolio value history to disk with open('portfolio_val/{}-{}.p'.format(timestamp, args.mode), 'wb') as fp: pickle.dump(portfolio_value, fp)
num_episodes = 2000 batch_size = 32 # for sampling from replay memory initial_investment = 20000 # Enable running the script with command line arguments (or not) cmd_line = False args_mode = 'test' if cmd_line: parser = argparse.ArgumentParser() parser.add_argument('-m', '--mode', type=str, required=True, help='--mode can be either "train" or "test"') args = parser.parse_args() args_mode = args.mode # Create directories, if not already exist. maybe_make_dir(models_folder) maybe_make_dir(rewards_folder) # Fetch time series try: data = get_data('./data/btc_ohlc_1d.csv') except: convert_to_ohlc() data = get_data('./data/btc_ohlc_1d.csv') n_timesteps, n_stocks = data.shape # Create train/test split train_ratio = 0.8 n_train = np.floor(n_timesteps * train_ratio).astype(int) train_data = data[:n_train]
def sample_cut(file_path, pre_adjust, post_adjust=None, verbose=False): utils.maybe_make_dir('./output/kick') utils.maybe_make_dir('./output/hi') utils.maybe_make_dir('./output/snare') pre_adjust = pre_adjust _, file_name = utils.split_head_and_tail(file_path) file_name = file_name.replace('.wav', '') if post_adjust is None: post_adjust = pre_adjust times = [ 11.5 + pre_adjust, 18.5 + post_adjust, 25.3 + pre_adjust, 32.2 + post_adjust, 39.3 + pre_adjust, 46.2 + post_adjust, 53 + pre_adjust, 60 + post_adjust, 66.5 + pre_adjust, 73.7 + post_adjust, 80.5 + pre_adjust, 87.5 + post_adjust, 94.2 + pre_adjust, 101.2 + post_adjust, 108 + pre_adjust, 115 + post_adjust ] # sec _ = pattern_cut(file_path, times) beats = [] labels = [] for n in range(8): name = 'p{:d}.wav'.format(n) y, sr = librosa.core.load(name, sr=constants.SR) beats_index = (librosa.time_to_samples(beat_comb_peakpick(name), sr=constants.SR)) n_beats = len(beats_index) if verbose: print('{}_p{:d}_#beat={:d}'.format(file_name, n, n_beats)) if n_beats < 10: print('Critical: {}_p{:d}_#beat={:d}'.format( file_name, n, n_beats)) continue elif n_beats < 16: # print('Warning: {}_p{:d}_#beat={:d}'.format(file_name, n, n_beats)) print('Critical: {}_p{:d}_#beat={:d}'.format( file_name, n, n_beats)) continue for m in range(n_beats): if m >= 16: break beat_index = beats_index[m] out = y[int(max(0, beat_index - constants.PRE_ONSET * constants.SR) ):int(beat_index + constants.POST_ONSET * constants.SR)] if m == 0: diff = beat_index - constants.BUFFER if m == 0 and abs(diff) > 0.1 * constants.SR: print('Large onset diff:{:d}ms {}, p{:d}, beat{:d}'.format( int(diff / constants.SR * 1e3), file_name, n, m)) beats.append(y) label = constants.LABEL[n, m] librosa.output.write_wav( get_beat_sample_path(label, file_name, n, m), out, sr) labels.append(label) if verbose: pass # librosa.output.write_wav('./output/'+str(p)+'/'+str(beat_number)+'_'+str(label[p,beat_n])+'.wav', out, sr) return beats, labels