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
