def run(self):
import time
while True:
time.sleep(1)
if self.q_size != self.queue.qsize():
self.q_size = self.queue.qsize()
print_progress(0, self.q_size, 'Progress', 'Complete', 1, 50)
def train_rbm(dr, wr, tr_beg_idx, tr_end_idx):
if not TRAIN_RBM:
return
# create rbm layers
rbmobject1, rbmobject2 = rbm_instance()
dr = dr[tr_beg_idx:tr_end_idx]
wr = wr[tr_beg_idx:tr_end_idx]
train_records = tr_end_idx - tr_beg_idx
data_indices = np.arange(train_records)
print("Training RBM layer 1")
batches_per_epoch = train_records // RBM_BATCH_SIZE
for i in range(RBM_EPOCH_TO_TRAIN):
np.random.shuffle(data_indices)
epoch_cost = 0.
curr_progress = 0
for b in range(batches_per_epoch):
# get data indices for slice
d_i_s = data_indices[b * RBM_BATCH_SIZE:(b + 1) * RBM_BATCH_SIZE]
_wr = wr[d_i_s, :]
_dr = dr[d_i_s, :]
input = np.concatenate([_wr, _dr], axis=1)
cost = rbmobject1.partial_fit(input)
epoch_cost += cost
curr_progress = progress.print_progress(curr_progress, b,
batches_per_epoch)
progress.print_progess_end()
print(" Epoch cost: {:.3f}".format(epoch_cost / batches_per_epoch))
rbmobject1.save_weights('./rbm/rbmw1.chp')
print("Training RBM layer 2")
for i in range(RBM_EPOCH_TO_TRAIN):
np.random.shuffle(data_indices)
epoch_cost = 0.
curr_progress = 0
for b in range(batches_per_epoch):
# get data indices for slice
d_i_s = data_indices[b * RBM_BATCH_SIZE:(b + 1) * RBM_BATCH_SIZE]
_wr = wr[d_i_s, :]
_dr = dr[d_i_s, :]
input = np.concatenate([_wr, _dr], axis=1)
input = rbmobject1.transform(input)
cost = rbmobject2.partial_fit(input)
epoch_cost += cost
curr_progress = progress.print_progress(curr_progress, b,
batches_per_epoch)
progress.print_progess_end()
print(" Epoch cost: {:.3f}".format(epoch_cost / batches_per_epoch))
rbmobject2.save_weights('./rbm/rbmw2.chp')
def validate_and_checkpoint():
model.eval()
# val_loss, val_acc = AverageMeter(), AverageMeter()
val_acc = AverageMeter()
for input, target in progress(val_loader):
# Load data
input_var, target_var = [d.cuda() for d in [input, target]]
# Evaluate model
with torch.no_grad():
output = model(input_var)
# loss, unreg_loss = criterion(output, target_var)
_, pred = output[0].max(1)
accuracy = (target_var.eq(pred)
).data.float().sum().item() / input.size(0)
# val_loss.update(loss.data.item(), input.size(0))
val_acc.update(accuracy, input.size(0))
# Check accuracy
# post_progress(l=val_loss.avg, a=val_acc.avg*100.0)
post_progress(a=val_acc.avg * 100.0)
# Save checkpoint
save_checkpoint(
{
'iter': iter_num,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'accuracy': val_acc.avg,
# 'loss': val_loss.avg,
},
val_acc.avg > best['val_accuracy'])
best['val_accuracy'] = max(val_acc.avg, best['val_accuracy'])
print_progress('Iteration %d val accuracy %.2f' %
(iter_num, val_acc.avg * 100.0))
def main():
parser = argparse.ArgumentParser(description='Adversarial test')
parser.add_argument('--expdir', type=str, default=None, required=True,
help='experiment directory containing model')
args = parser.parse_args()
progress = default_progress()
experiment_dir = args.expdir
perturbation1 = numpy.load('perturbation/VGG-19.npy')
perturbation = numpy.load('perturbation/perturb_synth.npy')
print('Original std %e new std %e' % (numpy.std(perturbation1),
numpy.std(perturbation)))
perturbation *= numpy.std(perturbation1) / numpy.std(perturbation)
# To deaturate uncomment.
# perturbation = numpy.repeat(perturbation[:,:,1:2], 3, axis=2)
val_loader = torch.utils.data.DataLoader(
CachedImageFolder('dataset/miniplaces/simple/val',
transform=transforms.Compose([
transforms.Resize(128),
transforms.CenterCrop(112),
AddPerturbation(perturbation[48:160,48:160]),
transforms.ToTensor(),
transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV),
])),
batch_size=32, shuffle=False,
num_workers=0, pin_memory=True)
# Create a simplified ResNet with half resolution.
model = CustomResNet(18, num_classes=100, halfsize=True)
checkpoint_filename = 'best_miniplaces.pth.tar'
best_checkpoint = os.path.join(experiment_dir, checkpoint_filename)
checkpoint = torch.load(best_checkpoint)
iter_num = checkpoint['iter']
model.load_state_dict(checkpoint['state_dict'])
model.eval()
model.cuda()
criterion = nn.CrossEntropyLoss().cuda()
val_loss, val_acc = AverageMeter(), AverageMeter()
for input, target in progress(val_loader):
# Load data
input_var, target_var = [d.cuda() for d in [input, target]]
# Evaluate model
with torch.no_grad():
output = model(input_var)
loss = criterion(output, target_var)
_, pred = output.max(1)
accuracy = (target_var.eq(pred)
).data.float().sum().item() / input.size(0)
val_loss.update(loss.data.item(), input.size(0))
val_acc.update(accuracy, input.size(0))
# Check accuracy
post_progress(l=val_loss.avg, a=val_acc.avg)
print_progress('Loss %e, validation accuracy %.4f' %
(val_loss.avg, val_acc.avg))
with open(os.path.join(experiment_dir, 'adversarial_test.json'), 'w') as f:
json.dump(dict(
adversarial_acc=val_acc.avg,
adversarial_loss=val_loss.avg), f)
def evaluate_ffnn(data_set_records, dr, wr, prob_l):
ffnn = ffnn_instance()
ffnn.load_weights('./rbm/ffnn.chp')
print("Evaluating")
b = 0
curr_progress = 0
batches_per_epoch = data_set_records // FFNN_BATCH_SIZE
while True:
start_idx = b * FFNN_BATCH_SIZE
end_idx = (b + 1) * FFNN_BATCH_SIZE
d_i_s = np.arange(start_idx, min(end_idx, data_set_records))
_wr = wr[d_i_s, :]
_dr = dr[d_i_s, :]
input = np.concatenate([_wr, _dr], axis=1)
p_dist = ffnn.predict(input)
for idx in d_i_s:
prob_l[idx] = p_dist[idx - start_idx, 0]
if end_idx >= data_set_records:
break
curr_progress = progress.print_progress(curr_progress, b,
batches_per_epoch)
b += 1
progress.print_progess_end()
def run_session(self, t, verbose=False, new_session=True):
"""Run a session for t steps.
Parameters:
t : Int. The number of iterations that the agent will act.
verbose : Boolean. Whether messages about the progress should be
displayed or not.
new_session : Boolean. Choose whether the session is new or not,
so as the Q and N gets initialized to zeros or not.
Notes: Actions A and rewards R are stored in arrays because they are
needed for later calculations.
"""
if new_session:
self.Q = np.zeros(self.k)
self.N = np.zeros(self.k)
A = np.zeros(t, dtype=np.int)
R = np.zeros(t, )
total_reward = np.zeros(t, )
for i in range(t):
A[i] = self.policy(self.policy_info[1])
R[i] = self.reward(A[i])
if i == 0:
total_reward[i] = R[i]
else:
total_reward[i] = total_reward[i - 1] + R[i]
self.N[A[i]] += 1
self.Q[A[i]] = self.Q[A[i]] + (1 / self.N[A[i]]) * (R[i] -
self.Q[A[i]])
if verbose:
prog.print_progress(i + 1,
t,
bar_length=50,
prefix="Running session...")
# The rewards taken and the actions chosen, for each individual step.
session_metrics = {
"R": R,
"A": A,
"total_reward": total_reward,
}
return session_metrics
def main():
progress = default_progress()
experiment_dir = 'experiment/resnet'
val_loader = torch.utils.data.DataLoader(
CachedImageFolder(
'dataset/miniplaces/simple/val',
transform=transforms.Compose([
transforms.Resize(128),
# transforms.CenterCrop(112),
transforms.ToTensor(),
transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV),
])),
batch_size=32,
shuffle=False,
num_workers=24,
pin_memory=True)
# Create a simplified ResNet with half resolution.
model = CustomResNet(18, num_classes=100, halfsize=True)
checkpoint_filename = 'best_miniplaces.pth.tar'
best_checkpoint = os.path.join(experiment_dir, checkpoint_filename)
checkpoint = torch.load(best_checkpoint)
iter_num = checkpoint['iter']
model.load_state_dict(checkpoint['state_dict'])
model.eval()
model.cuda()
criterion = nn.CrossEntropyLoss().cuda()
val_loss, val_acc = AverageMeter(), AverageMeter()
for input, target in progress(val_loader):
# Load data
input_var, target_var = [d.cuda() for d in [input, target]]
# Evaluate model
with torch.no_grad():
output = model(input_var)
loss = criterion(output, target_var)
_, pred = output.max(1)
accuracy = (
target_var.eq(pred)).data.float().sum().item() / input.size(0)
val_loss.update(loss.data.item(), input.size(0))
val_acc.update(accuracy, input.size(0))
# Check accuracy
post_progress(l=val_loss.avg, a=val_acc.avg)
print_progress('Loss %e, validation accuracy %.4f' %
(val_loss.avg, val_acc.avg))
def __init__(self, equation, grid_size, show_prog=True):
# Generate an array of x position and y positions for each pos we sample
self.x, self.y = np.mgrid[slice(0, 1 + 1 / grid_size[0], 1 /
grid_size[0]),
slice(0, 1 + 1 / grid_size[1], 1 /
grid_size[1])]
# Initialise the array holding the sample values
self.z = np.zeros((len(self.x), len(self.y)))
# Iterate through all sample positions
for ypos in range(grid_size[1] + 1):
for xpos in range(grid_size[0] + 1):
# Update progress bar
if show_prog:
progress.print_progress(
xpos + ypos * (grid_size[0] + 1) + 1,
(grid_size[0] + 1) * (grid_size[1] + 1))
# Calcuate sample position's value
self.z[xpos, ypos] = equation(self.x[xpos, ypos], self.y[xpos,
ypos])
def train_ae(dr, wr, tr_beg_idx, tr_end_idx):
if not TRAIN_AU:
return
autoencoder = ae_instance()
print("Training Autoencoder")
dr = dr[tr_beg_idx:tr_end_idx]
wr = wr[tr_beg_idx:tr_end_idx]
train_records = tr_end_idx - tr_beg_idx
data_indices = np.arange(train_records)
if LOAD_RBM_WEIGHTS:
autoencoder.load_rbm_weights('./rbm/rbmw1.chp', ['rbmw1', 'rbmhb1'], 0)
autoencoder.load_rbm_weights('./rbm/rbmw2.chp', ['rbmw2', 'rbmhb2'], 1)
batches_per_epoch = train_records // AU_BATCH_SIZE
for i in range(AU_EPOCH_TO_TRAIN):
np.random.shuffle(data_indices)
epoch_cost = 0.
curr_progress = 0
for b in range(batches_per_epoch):
# get data indices for slice
d_i_s = data_indices[b * AU_BATCH_SIZE:(b + 1) * AU_BATCH_SIZE]
_wr = wr[d_i_s, :]
_dr = dr[d_i_s, :]
input = np.concatenate([_wr, _dr], axis=1)
cost = autoencoder.partial_fit(input)
# print("Batch cost: {:.3f}".format(cost))
epoch_cost += cost
curr_progress = progress.print_progress(curr_progress, b,
batches_per_epoch)
progress.print_progess_end()
print(" Epoch cost: {:.3f}".format(epoch_cost / batches_per_epoch))
autoencoder.save_weights('./rbm/au.chp')
def __init__(self, alpha, beta):
print_progress('Using Dual with alpha %e beta %e' % (alpha, beta))
self.alpha = alpha
self.beta = beta
def train(net):
create_folders()
env = Env()
# net = NetShiva()
if not os.path.exists(get_config().TRAIN_STAT_PATH):
with open(get_config().TRAIN_STAT_PATH, 'a', newline='') as f:
writer = csv.writer(f)
writer.writerow(
('epoch', 'tr loss', 'tr dd', 'tr sharpe', 'tr y avg',
'tst loss', 'tst dd', 'tst sharpe', 'tst y avg'))
total_tickers = len(env.tickers)
def open_train_stat_file():
return open(get_config().TRAIN_STAT_PATH, 'a', newline='')
def is_train():
return get_config().MODE == Mode.TRAIN
with open_train_stat_file() if is_train() else dummy_context_mgr() as f:
if is_train():
writer = csv.writer(f)
if get_config().EPOCH_WEIGHTS_TO_LOAD != 0:
net.load_weights(get_config().WEIGHTS_PATH,
get_config().EPOCH_WEIGHTS_TO_LOAD)
epoch = get_config().EPOCH_WEIGHTS_TO_LOAD
if is_train():
epoch += 1
else:
net.init()
epoch = 0
def get_net_data(BEG, END):
beg_idx, end_idx = env.get_data_idxs_range(BEG, END)
raw_dates = env.get_raw_dates(beg_idx, end_idx)
input = env.get_input(beg_idx, end_idx)
px = env.get_adj_close_px(beg_idx, end_idx)
px_pred_hor = env.get_adj_close_px(
beg_idx + get_config().PRED_HORIZON,
end_idx + get_config().PRED_HORIZON)
tradeable_mask = env.get_tradeable_mask(beg_idx, end_idx)
port_mask = env.get_portfolio_mask(beg_idx, end_idx)
ds_sz = px_pred_hor.shape[1]
raw_dates = raw_dates[:ds_sz]
raw_week_days = np.full(raw_dates.shape, 0, dtype=np.int32)
for i in range(raw_dates.shape[0]):
date = date_from_timestamp(raw_dates[i])
raw_week_days[i] = date.isoweekday()
input = input[:, :ds_sz, :]
tradeable_mask = tradeable_mask[:, :ds_sz]
port_mask = port_mask[:, :ds_sz]
px = px[:, :ds_sz]
labels = (px_pred_hor - px) / px
batch_num = get_batches_num(ds_sz, get_config().BPTT_STEPS)
return beg_idx, ds_sz, batch_num, raw_dates, raw_week_days, tradeable_mask, port_mask, px, input, labels
tr_beg_data_idx, tr_ds_sz, tr_batch_num, tr_raw_dates, tr_week_days, tr_tradeable_mask, tr_port_mask, tr_px, tr_input, tr_labels = get_net_data(
get_config().TRAIN_BEG,
get_config().TRAIN_END)
tr_eq = np.zeros((tr_ds_sz))
tr_pred = np.zeros((total_tickers, tr_ds_sz))
if get_config().TEST:
tst_beg_data_idx, tst_ds_sz, tst_batch_num, tst_raw_dates, tst_week_days, tst_tradeable_mask, tst_port_mask, tst_px, tst_input, tst_labels = get_net_data(
get_config().TEST_BEG,
get_config().TEST_END)
tst_eq = np.zeros((tst_ds_sz))
tst_pred = np.zeros((total_tickers, tst_ds_sz))
def get_batch_range(b):
return b * get_config().BPTT_STEPS, (b +
1) * get_config().BPTT_STEPS
while epoch <= get_config().MAX_EPOCH:
print("Eval %d epoch on train set..." % epoch)
batch_num = tr_batch_num
ds_size = tr_ds_sz
input = tr_input
labels = tr_labels
px = tr_px
mask = tr_tradeable_mask
port_mask = tr_port_mask
eq = tr_eq
beg_data_idx = tr_beg_data_idx
raw_dates = tr_raw_dates
pred_hist = tr_pred
state = None
def eval_with_state_reset():
nonlocal raw_dates, beg_data_idx, ds_size, batch_num, input, labels, px, mask, port_mask, eq, pred_hist, state
curr_progress = 0
cash = 1
pos = np.zeros((total_tickers))
pos_px = np.zeros((total_tickers))
losses = np.zeros((batch_num))
for i in range(ds_size):
state = net.zero_state(total_tickers)
b_b_i = max(0,
i + 1 - get_config().RESET_HIDDEN_STATE_FREQ)
b_e_i = i + 1
_input = input[:, b_b_i:b_e_i, :]
_labels = labels[:, b_b_i:b_e_i]
_mask = mask[:, b_b_i:b_e_i]
state, loss, predictions = net.eval(
state, _input, _labels, _mask.astype(np.float32))
pred_hist[:, i] = predictions[:, -1, 0]
data_idx = i
curr_px = px[:, data_idx]
global_data_idx = beg_data_idx + data_idx
date = datetime.datetime.fromtimestamp(
raw_dates[data_idx]).date()
open_pos = False
close_pos = False
if get_config().REBALANCE_FRI:
if date.isoweekday() == 5:
open_pos = True
if date.isoweekday() == 5:
close_pos = True
else:
if data_idx % get_config().REBALANCE_FREQ == 0:
close_pos = True
open_pos = True
if close_pos:
rpl = np.sum(pos * (curr_px - pos_px))
cash += rpl
pos[:] = 0
if open_pos:
pos_px = curr_px
pos_mask = port_mask[:, data_idx]
num_stks = np.sum(pos_mask)
if get_config().CAPM:
exp, cov = env.get_exp_and_cov(
pos_mask, global_data_idx -
get_config().COVARIANCE_LENGTH + 1,
global_data_idx)
exp = get_config().REBALANCE_FREQ * exp
cov = get_config().REBALANCE_FREQ * get_config(
).REBALANCE_FREQ * cov
if get_config().CAPM_USE_NET_PREDICTIONS:
exp = predictions[:, i, 0][pos_mask]
capm = Capm(num_stks)
capm.init()
best_sharpe = None
best_weights = None
best_constriant = None
while i <= 10000:
w, sharpe, constraint = capm.get_params(
exp, cov)
# print("Iteration: %d Sharpe: %.2f Constraint: %.6f" % (i, sharpe, constraint))
if w is None:
break
if best_sharpe is None or sharpe >= best_sharpe:
best_weights = w
best_sharpe = sharpe
best_constriant = constraint
capm.fit(exp, cov)
capm.rescale_weights()
i += 1
date = datetime.datetime.fromtimestamp(
raw_dates[data_idx]).date()
print("Date: %s sharpe: %.2f constraint: %.6f" %
(date.strftime('%Y-%m-%d'), best_sharpe,
best_constriant))
pos[pos_mask] = best_weights / curr_px[pos_mask]
else:
pos[pos_mask] = 1 / num_stks / curr_px[
pos_mask] * np.sign(predictions[pos_mask, -1,
0])
urpl = np.sum(pos * (curr_px - pos_px))
nlv = cash + urpl
eq[data_idx] = nlv
curr_progress = progress.print_progress(
curr_progress, i, ds_size)
progress.print_progess_end()
avg_loss = np.mean(np.sqrt(losses))
return avg_loss
def eval():
nonlocal raw_dates, beg_data_idx, ds_size, batch_num, input, labels, px, mask, port_mask, eq, pred_hist, state
curr_progress = 0
cash = 1
pos = np.zeros((total_tickers))
pos_px = np.zeros((total_tickers))
losses = np.zeros((batch_num))
for b in range(batch_num):
if state is None:
state = net.zero_state(total_tickers)
b_b_i, b_e_i = get_batch_range(b)
_input = input[:, b_b_i:b_e_i, :]
_labels = labels[:, b_b_i:b_e_i]
_mask = mask[:, b_b_i:b_e_i]
state, loss, predictions = net.eval(
state, _input, _labels, _mask.astype(np.float32))
pred_hist[:, b_b_i:b_e_i] = predictions[:, :, 0]
for i in range(predictions.shape[1]):
data_idx = b * get_config().BPTT_STEPS + i
curr_px = px[:, data_idx]
global_data_idx = beg_data_idx + data_idx
date = datetime.datetime.fromtimestamp(
raw_dates[data_idx]).date()
open_pos = False
close_pos = False
if get_config().REBALANCE_FRI:
if date.isoweekday() == 5:
open_pos = True
if date.isoweekday() == 5:
close_pos = True
else:
if data_idx % get_config().REBALANCE_FREQ == 0:
close_pos = True
open_pos = True
if close_pos:
rpl = np.sum(pos * (curr_px - pos_px))
cash += rpl
pos[:] = 0
if open_pos:
pos_px = curr_px
pos_mask = port_mask[:, data_idx]
num_stks = np.sum(pos_mask)
if get_config().CAPM:
exp, cov = env.get_exp_and_cov(
pos_mask, global_data_idx -
get_config().COVARIANCE_LENGTH + 1,
global_data_idx)
exp = get_config().REBALANCE_FREQ * exp
cov = get_config().REBALANCE_FREQ * get_config(
).REBALANCE_FREQ * cov
if get_config().CAPM_USE_NET_PREDICTIONS:
exp = predictions[:, i, 0][pos_mask]
capm = Capm(num_stks)
capm.init()
best_sharpe = None
best_weights = None
best_constriant = None
while i <= 10000:
w, sharpe, constraint = capm.get_params(
exp, cov)
# print("Iteration: %d Sharpe: %.2f Constraint: %.6f" % (i, sharpe, constraint))
if w is None:
break
if best_sharpe is None or sharpe >= best_sharpe:
best_weights = w
best_sharpe = sharpe
best_constriant = constraint
capm.fit(exp, cov)
capm.rescale_weights()
i += 1
date = datetime.datetime.fromtimestamp(
raw_dates[data_idx]).date()
print(
"Date: %s sharpe: %.2f constraint: %.6f" %
(date.strftime('%Y-%m-%d'), best_sharpe,
best_constriant))
pos[pos_mask] = best_weights / curr_px[pos_mask]
else:
pos[pos_mask] = 1 / num_stks / curr_px[
pos_mask] * np.sign(predictions[pos_mask,
i, 0])
urpl = np.sum(pos * (curr_px - pos_px))
nlv = cash + urpl
eq[data_idx] = nlv
losses[b] = loss
curr_progress = progress.print_progress(
curr_progress, b, tr_batch_num)
progress.print_progess_end()
avg_loss = np.mean(np.sqrt(losses))
return avg_loss
if get_config().RESET_HIDDEN_STATE_FREQ == 0:
tr_avg_loss = eval()
else:
tr_avg_loss = eval_with_state_reset()
print("Train loss: %.4f%%" % (tr_avg_loss * 100))
if get_config().TEST:
print("Eval %d epoch on test set..." % epoch)
batch_num = tst_batch_num
ds_size = tr_ds_sz
input = tst_input
labels = tst_labels
px = tst_px
mask = tst_tradeable_mask
port_mask = tst_port_mask
eq = tst_eq
beg_data_idx = tst_beg_data_idx
raw_dates = tst_raw_dates
pred_hist = tst_pred
state = None
if get_config().RESET_HIDDEN_STATE_FREQ == 0:
tst_avg_loss = eval()
else:
tst_avg_loss = eval_with_state_reset()
print("Test loss: %.4f%%" % (tst_avg_loss * 100))
if not is_train():
dt = build_time_axis(tr_raw_dates)
if not get_config().HIDE_PLOTS:
plot_eq('Train',
get_config().TRAIN_BEG,
get_config().TRAIN_END, dt, tr_eq)
result = pd.DataFrame(columns=('date', 'ticker', 'prediction'))
for i in range(tr_raw_dates.shape[0]):
date = dt[i]
for j in range(total_tickers):
ticker = env._idx_to_ticker(j)
prediction = tr_pred[j, i]
row = [date, ticker, prediction]
result.loc[i * total_tickers + j] = row
result.to_csv(get_config().TRAIN_PRED_PATH, index=False)
if get_config().TEST:
dt = build_time_axis(tst_raw_dates)
if not get_config().HIDE_PLOTS:
plot_eq('Test',
get_config().TEST_BEG,
get_config().TEST_END, dt, tst_eq)
if not get_config().HIDE_PLOTS:
show_plots()
break
if is_train() and epoch <= get_config().MAX_EPOCH:
# plot and save graphs
dt = build_time_axis(tr_raw_dates)
fig, tr_dd, tr_sharpe, tr_y_avg = plot_eq(
'Train',
get_config().TRAIN_BEG,
get_config().TRAIN_END, dt, tr_eq)
fig.savefig('%s/%04d.png' %
(get_config().TRAIN_FIG_PATH, epoch))
plt.close(fig)
if get_config().TEST:
dt = build_time_axis(tst_raw_dates)
fig, tst_dd, tst_sharpe, tst_y_avg = plot_eq(
'Test',
get_config().TEST_BEG,
get_config().TEST_END, dt, tst_eq)
fig.savefig('%s/%04d.png' %
(get_config().TEST_FIG_PATH, epoch))
plt.close(fig)
else:
tst_avg_loss = 0
tst_dd = 0
tst_sharpe = 0
tst_y_avg = 0
writer.writerow((
epoch,
tr_avg_loss,
tr_dd,
tr_sharpe,
tr_y_avg,
tst_avg_loss,
tst_dd,
tst_sharpe,
tst_y_avg,
))
f.flush()
if epoch == get_config().MAX_EPOCH:
tr_df = pd.DataFrame({'date': dt, 'capital': tr_eq[:]})
tr_df.to_csv(get_config().TRAIN_EQ_PATH, index=False)
if get_config().TEST:
tst_df = pd.DataFrame({
'date': dt,
'capital': tst_eq[:]
})
tst_df.to_csv(get_config().TEST_EQ_PATH, index=False)
epoch += 1
if epoch > get_config().MAX_EPOCH:
break
print("Training %d epoch..." % epoch)
curr_progress = 0
state = None
for b in range(tr_batch_num):
if state is None:
state = net.zero_state(total_tickers)
b_b_i, b_e_i = get_batch_range(b)
_input = tr_input[:, b_b_i:b_e_i, :]
_labels = tr_labels[:, b_b_i:b_e_i]
_mask = tr_tradeable_mask[:, b_b_i:b_e_i]
if get_config().FIT_FRI_PREDICTION_ONLY:
batch_week_days = tr_week_days[b_b_i:b_e_i]
batch_mon_mask = batch_week_days == 5
for i in range(_mask.shape[0]):
_mask[i, :] = _mask[i, :] & batch_mon_mask
state, loss, predictions = net.fit(
state, _input, _labels, _mask.astype(np.float32))
curr_progress = progress.print_progress(
curr_progress, b, tr_batch_num)
progress.print_progess_end()
net.save_weights(get_config().WEIGHTS_PATH, epoch)
def __init__(self, beta):
print_progress('Using FiltBot with %e' % beta)
self.beta = beta
def calc_classes_and_decisions(data_set_records, total_weeks, prob_l):
c_l = np.zeros((data_set_records), dtype=np.bool)
c_s = np.zeros((data_set_records), dtype=np.bool)
s_l = np.zeros((data_set_records), dtype=np.bool)
s_s = np.zeros((data_set_records), dtype=np.bool)
model_no_sl_hpr = np.zeros((total_weeks))
min_w_eod_hpr_no_sl = np.zeros((total_weeks))
min_w_lb_hpr_no_sl = np.zeros((total_weeks))
l_port_no_sl = np.empty((total_weeks), dtype=np.object)
s_port_no_sl = np.empty((total_weeks), dtype=np.object)
l_stops_no_sl = np.zeros((total_weeks))
s_stops_no_sl = np.zeros((total_weeks))
min_to = np.zeros((total_weeks))
avg_to = np.zeros((total_weeks))
longs = np.zeros((total_weeks))
shorts = np.zeros((total_weeks))
selection = np.zeros((total_weeks))
model_eod_sl_hpr = np.zeros((total_weeks))
min_w_eod_hpr_eod_sl = np.zeros((total_weeks))
min_w_lb_hpr_eod_sl = np.zeros((total_weeks))
l_port_eod_sl = np.empty((total_weeks), dtype=np.object)
s_port_eod_sl = np.empty((total_weeks), dtype=np.object)
l_stops_eod_sl = np.zeros((total_weeks))
s_stops_eod_sl = np.zeros((total_weeks))
model_lb_sl_hpr = np.zeros((total_weeks))
min_w_eod_hpr_lb_sl = np.zeros((total_weeks))
min_w_lb_hpr_lb_sl = np.zeros((total_weeks))
l_port_lb_sl = np.empty((total_weeks), dtype=np.object)
s_port_lb_sl = np.empty((total_weeks), dtype=np.object)
l_stops_lb_sl = np.zeros((total_weeks))
s_stops_lb_sl = np.zeros((total_weeks))
model_s_sl_hpr = np.zeros((total_weeks))
min_w_eod_hpr_s_sl = np.zeros((total_weeks))
min_w_lb_hpr_s_sl = np.zeros((total_weeks))
l_port_s_sl = np.empty((total_weeks), dtype=np.object)
s_port_s_sl = np.empty((total_weeks), dtype=np.object)
l_stops_s_sl = np.zeros((total_weeks))
s_stops_s_sl = np.zeros((total_weeks))
print('Calculating...')
curr_progress = 0
for i in range(total_weeks):
curr_progress = progress.print_progress(curr_progress, i, total_weeks)
w_i = i
beg = w_data_index[w_i]
end = beg + w_num_stocks[w_i]
_prob_l = prob_l[beg:end]
prob_median = np.median(_prob_l)
prob_median = 0.5
_s_c_l = c_l[beg:end]
_s_c_s = c_s[beg:end]
pred_long_cond = _prob_l >= prob_median
_s_c_l |= pred_long_cond
_s_c_s |= ~pred_long_cond
_s_s_l = s_l[beg:end]
_s_s_s = s_s[beg:end]
_int_r = s_int_r[beg:end]
# # third variant: no net
# _int_r_sorted = np.sort(_int_r)
# _sel_stks = min(get_config().SLCT_VAL, _int_r_sorted.shape[0])
# if _sel_stks == 0:
# continue
# _l_b = _int_r_sorted[_sel_stks - 1]
# _s_b = _int_r_sorted[-_sel_stks]
# sel_l_cond = ~_s_s_l
# sel_l_cond &= _int_r <= _l_b
# sel_s_cond = ~_s_s_s
# sel_s_cond &= _int_r >= _s_b
# second variant - metric
# by yield
_metric = np.sign(_prob_l - prob_median) * _int_r
# by prob * yield
# _metric = (_prob_l - prob_median) * _int_r
_metric_l = _metric[pred_long_cond]
_metric_s = _metric[~pred_long_cond]
_metric_sorted_l = np.sort(_metric_l)
_metric_sorted_s = np.sort(_metric_s)
MOD = False
if MOD:
_metric_sorted_l = _metric_sorted_l[_metric_sorted_l >= 0]
_metric_sorted_s = _metric_sorted_s[_metric_sorted_s >= 0]
_sel_stks = min(get_config().SLCT_VAL, _metric_sorted_l.shape[0])
if _sel_stks == 0:
continue
_l_b = _metric_sorted_l[_sel_stks - 1]
_sel_stks = min(get_config().SLCT_VAL, _metric_sorted_s.shape[0])
if _sel_stks == 0:
continue
_s_b = _metric_sorted_s[_sel_stks - 1]
sel_l_cond = _s_s_l
sel_l_cond |= pred_long_cond
sel_l_cond &= (_metric <= _l_b) & (_metric >= 0)
sel_s_cond = _s_s_s
sel_s_cond |= ~pred_long_cond
sel_s_cond &= (_metric <= _s_b) & (_metric >= 0)
else:
_sel_stks = min(get_config().SLCT_VAL, _metric_sorted_l.shape[0])
_l_b = _metric_sorted_l[_sel_stks - 1]
_sel_stks = min(get_config().SLCT_VAL, _metric_sorted_s.shape[0])
_s_b = _metric_sorted_s[_sel_stks - 1]
sel_l_cond = _s_s_l
sel_l_cond |= pred_long_cond
sel_l_cond &= (_metric <= _l_b)
sel_s_cond = _s_s_s
sel_s_cond |= ~pred_long_cond
sel_s_cond &= (_metric <= _s_b)
# # initial variant
# if get_config().SLCT_TYPE == SelectionType.PCT:
# top_bound = np.percentile(_prob_l, 100 - get_config().SLCT_VAL)
# bottom_bound = np.percentile(_prob_l, get_config().SLCT_VAL)
# else:
# _prob_l_sorted = np.sort(_prob_l)
# _sel_stks = min(get_config().SLCT_VAL, _prob_l_sorted.shape[0])
# bottom_bound = _prob_l_sorted[_sel_stks - 1]
# top_bound = _prob_l_sorted[-_sel_stks]
#
# long_cond = _prob_l >= top_bound
# short_cond = _prob_l <= bottom_bound
# _s_s_l |= long_cond
# _s_s_s |= short_cond
#
# l_s_int_r = _int_r[_s_s_l]
# s_s_int_r = _int_r[_s_s_s]
#
# if get_config().SLCT_ALG == SelectionAlgo.CONFIRMED:
# l_int_r_t_b = np.max(l_s_int_r)
# l_int_r_b_b = np.percentile(l_s_int_r, 100 - get_config().SLCT_PCT)
# elif get_config().SLCT_ALG == SelectionAlgo.NON_CONFIRMED:
# l_int_r_t_b = np.percentile(l_s_int_r, get_config().SLCT_PCT)
# l_int_r_b_b = np.min(l_s_int_r)
# elif get_config().SLCT_ALG == SelectionAlgo.MIDDLE:
# l_int_r_t_b = np.percentile(l_s_int_r, 100 - get_config().SLCT_PCT / 2)
# l_int_r_b_b = np.percentile(l_s_int_r, get_config().SLCT_PCT / 2)
#
# if get_config().SLCT_ALG == SelectionAlgo.CONFIRMED:
# s_int_r_t_b = np.percentile(s_s_int_r, get_config().SLCT_PCT)
# s_int_r_b_b = np.min(s_s_int_r)
# elif get_config().SLCT_ALG == SelectionAlgo.NON_CONFIRMED:
# s_int_r_t_b = np.max(s_s_int_r)
# s_int_r_b_b = np.percentile(s_s_int_r, 100 - get_config().SLCT_PCT)
# elif get_config().SLCT_ALG == SelectionAlgo.MIDDLE:
# s_int_r_t_b = np.percentile(s_s_int_r, 100 - get_config().SLCT_PCT / 2)
# s_int_r_b_b = np.percentile(s_s_int_r, get_config().SLCT_PCT / 2)
#
# sel_l_cond = _s_s_l
# sel_l_cond &= _int_r >= l_int_r_b_b
# sel_l_cond &= _int_r <= l_int_r_t_b
#
# sel_s_cond = _s_s_s
# sel_s_cond &= _int_r <= s_int_r_t_b
# sel_s_cond &= _int_r >= s_int_r_b_b
# select long and short stocks in portfolio
_stocks = stocks[beg:end]
_l_stocks = _stocks[sel_l_cond]
_s_stocks = _stocks[sel_s_cond]
_t_w_eod_num = t_w_eod_num[w_i]
_t_w_eods = t_w_eods[w_i, :_t_w_eod_num]
# select eod hpr by stock during the week
_t_w_s_s_hpr = t_w_s_hpr[beg:end, :_t_w_eod_num]
_t_w_l_s_hpr = _t_w_s_s_hpr[sel_l_cond, :]
_t_w_s_s_hpr = _t_w_s_s_hpr[sel_s_cond, :]
# select lb hpr by stock during the week
_t_w_s_s_h_hpr = t_w_s_h_hpr[beg:end, :_t_w_eod_num]
_t_w_s_s_l_hpr = t_w_s_l_hpr[beg:end, :_t_w_eod_num]
_t_w_l_s_lb_hpr = _t_w_s_s_l_hpr[sel_l_cond, :]
_t_w_s_s_lb_hpr = _t_w_s_s_h_hpr[sel_s_cond, :]
# select hpr by stock during the week using open px
_t_w_ss_o_hpr = t_w_s_o_hpr[beg:end, :_t_w_eod_num]
_t_w_l_s_o_hpr = _t_w_ss_o_hpr[sel_l_cond, :]
_t_w_s_s_o_hpr = _t_w_ss_o_hpr[sel_s_cond, :]
# calc portfolio metrics
_avg_s_to = avg_s_to[beg:end]
_l_avg_s_to = _avg_s_to[sel_l_cond]
_s_avg_s_to = _avg_s_to[sel_s_cond]
_min_to = min(np.min(_l_avg_s_to), np.min(_s_avg_s_to))
_avg_to = (np.mean(_l_avg_s_to) + np.mean(_s_avg_s_to)) / 2
_longs = _l_stocks.shape[0]
_shorts = _s_stocks.shape[0]
min_to[w_i] = _min_to
avg_to[w_i] = _avg_to
longs[w_i] = _longs
shorts[w_i] = _shorts
selection[w_i] = _prob_l.shape[0]
def calc_params(override_ext_lb_hpr, _t_w_eods, t_w_l_s_hpr,
t_w_s_s_hpr, t_w_l_s_lb_hpr, t_w_s_s_lb_hpr,
_s_l_ext_idx, _s_s_ext_idx, _s_l_stop, _s_s_stop,
_s_l_ext_hpr, _s_s_ext_hpr):
# create arrays copy
_t_w_l_s_hpr = np.copy(t_w_l_s_hpr)
_t_w_s_s_hpr = np.copy(t_w_s_s_hpr)
_t_w_l_s_lb_hpr = np.copy(t_w_l_s_lb_hpr)
_t_w_s_s_lb_hpr = np.copy(t_w_s_s_lb_hpr)
# fill proper array values
for idx in range(_s_l_ext_idx.shape[0]):
_ext_idx = _s_l_ext_idx[idx]
_ext_hpr = _s_l_ext_hpr[idx]
_t_w_l_s_hpr[idx, _ext_idx:] = _ext_hpr
_t_w_l_s_lb_hpr[idx,
_ext_idx if override_ext_lb_hpr else _ext_idx +
1:] = _ext_hpr
for idx in range(_s_s_ext_idx.shape[0]):
_ext_idx = _s_s_ext_idx[idx]
_ext_hpr = _s_s_ext_hpr[idx]
_t_w_s_s_hpr[idx, _ext_idx:] = _ext_hpr
_t_w_s_s_lb_hpr[idx,
_ext_idx if override_ext_lb_hpr else _ext_idx +
1:] = _ext_hpr
# calc portfolio hpr
_l_s_hpr = _t_w_l_s_hpr[:, -1]
_s_s_hpr = _t_w_s_s_hpr[:, -1]
_l_hpr = np.mean(_l_s_hpr)
_s_hpr = np.mean(_s_s_hpr)
_w_hpr = np.zeros(_l_hpr.shape)
_w_hpr = (_l_hpr - get_config().SLIPPAGE) * get_config(
).LONG_ALLOC_PCT - (
_s_hpr - get_config().SLIPPAGE) * get_config().SHORT_ALLOC_PCT
# if get_config().LONG_LEG:
# _w_hpr += _l_hpr
# if get_config().SHORT_LEG:
# _w_hpr -= _s_hpr
# if get_config().LONG_LEG and get_config().SHORT_LEG:
# _w_hpr /= 2
# _w_hpr = (_l_hpr - _s_hpr) / 2
# calc min w eod hpr
_t_w_l_s_hpr_mean = np.mean(_t_w_l_s_hpr, axis=0)
_t_w_s_s_hpr_mean = np.mean(_t_w_s_s_hpr, axis=0)
_t_w_hpr = np.zeros(_t_w_l_s_hpr_mean.shape)
_t_w_hpr = _t_w_l_s_hpr_mean * get_config(
).LONG_ALLOC_PCT - _t_w_s_s_hpr_mean * get_config().SHORT_ALLOC_PCT
# if get_config().LONG_LEG:
# _t_w_hpr += _t_w_l_s_hpr_mean
# if get_config().SHORT_LEG:
# _t_w_hpr -= _t_w_s_s_hpr_mean
# if get_config().LONG_LEG and get_config().SHORT_LEG:
# _t_w_hpr /= 2
# _t_w_hpr = (_t_w_l_s_hpr_mean - _t_w_s_s_hpr_mean) / 2
_min_w_eod_hpr = np.min(_t_w_hpr)
# calc lower bound weekly min
_t_w_l_s_lb_hpr_mean = np.mean(_t_w_l_s_lb_hpr, axis=0)
_t_w_s_s_lb_hpr_mean = np.mean(_t_w_s_s_lb_hpr, axis=0)
_t_w_lb_hpr = np.zeros(_t_w_l_s_lb_hpr_mean.shape)
_t_w_lb_hpr = _t_w_l_s_lb_hpr_mean * get_config(
).LONG_ALLOC_PCT - _t_w_s_s_lb_hpr_mean * get_config(
).SHORT_ALLOC_PCT
# if get_config().LONG_LEG:
# _t_w_lb_hpr += _t_w_l_s_lb_hpr_mean
# if get_config().SHORT_LEG:
# _t_w_lb_hpr -= _t_w_s_s_lb_hpr_mean
# if get_config().LONG_LEG and get_config().SHORT_LEG:
# _t_w_lb_hpr /= 2
# _t_w_lb_hpr = (_t_w_l_s_lb_hpr_mean - _t_w_s_s_lb_hpr_mean) / 2
_min_w_lb_hpr = np.min(_t_w_lb_hpr)
# calc portfolio string
_longs_df = None
_shorts_df = None
if not get_config().GRID_SEARCH and get_config().PRINT_PORTFOLIO:
_l_prob_l = _prob_l[sel_l_cond]
_s_prob_l = _prob_l[sel_s_cond]
# _longs_df = pd.DataFrame(index=np.arange(0, len(_l_stocks)), columns=('ticker', 'ret', 'ext', 'awto','p'))
# _shorts_df = pd.DataFrame(index=np.arange(0, len(_s_stocks)), columns=('ticker', 'ret', 'ext', 'awto','p'))
_longs_df = np.empty((_l_stocks.shape[0], 5), dtype=np.object)
_shorts_df = np.empty((_s_stocks.shape[0], 5), dtype=np.object)
idx = 0
for _stock_idx in _l_stocks:
_dt_ext = datetime.datetime.fromtimestamp(
raw_dt[_t_w_eods[_s_l_ext_idx[idx]]])
_s_dt_ext = _dt_ext.strftime('%Y-%m-%d')
# _longs_df.loc[idx].ticker = tickers[_stock_idx]
# _longs_df.loc[idx].ret = _l_s_hpr[idx]
# _longs_df.loc[idx].ext = _s_dt_ext
# _longs_df.loc[idx].awto = _l_avg_s_to[idx]
# _longs_df.loc[idx].p = _l_prob_l[idx]
_longs_df[idx, 0] = tickers[_stock_idx]
_longs_df[idx, 1] = _l_s_hpr[idx]
_longs_df[idx, 2] = _s_dt_ext
_longs_df[idx, 3] = _l_avg_s_to[idx]
_longs_df[idx, 4] = _l_prob_l[idx]
idx += 1
idx = 0
for _stock_idx in _s_stocks:
_dt_ext = datetime.datetime.fromtimestamp(
raw_dt[_t_w_eods[_s_s_ext_idx[idx]]])
_s_dt_ext = _dt_ext.strftime('%Y-%m-%d')
# _shorts_df.loc[idx].ticker = tickers[_stock_idx]
# _shorts_df.loc[idx].ret = _s_s_hpr[idx]
# _shorts_df.loc[idx].ext = _s_dt_ext
# _shorts_df.loc[idx].awto = _s_avg_s_to[idx]
# _shorts_df.loc[idx].p = _s_prob_l[idx]
_shorts_df[idx, 0] = tickers[_stock_idx]
_shorts_df[idx, 1] = _s_s_hpr[idx]
_shorts_df[idx, 2] = _s_dt_ext
_shorts_df[idx, 3] = _s_avg_s_to[idx]
_shorts_df[idx, 4] = _s_prob_l[idx]
idx += 1
# calc long and short stops
_l_stops = np.sum(_s_l_stop)
_s_stops = np.sum(_s_s_stop)
return _l_hpr, _s_hpr, _w_hpr, _min_w_eod_hpr, _min_w_lb_hpr, _l_stops, _s_stops, _longs_df, _shorts_df, _min_to, _avg_to
_default_ext_idx = _t_w_eod_num - 1
# calc no sl model
_s_l_ext_idx = np.full(_l_stocks.shape, _t_w_eod_num - 1)
_s_s_ext_idx = np.full(_s_stocks.shape, _t_w_eod_num - 1)
_s_l_stop = np.full(_l_stocks.shape, False)
_s_s_stop = np.full(_l_stocks.shape, False)
_s_l_ext_hpr = _t_w_l_s_hpr[:, _t_w_eod_num - 1]
_s_s_ext_hpr = _t_w_s_s_hpr[:, _t_w_eod_num - 1]
_l_hpr, _s_hpr, _w_hpr, _min_w_eod_hpr, _min_w_lb_hpr, _l_stops, _s_stops, _s_longs, _s_shorts, _min_to, _avg_to = calc_params(
False, _t_w_eods, _t_w_l_s_hpr, _t_w_s_s_hpr, _t_w_l_s_lb_hpr,
_t_w_s_s_lb_hpr, _s_l_ext_idx, _s_s_ext_idx, _s_l_stop, _s_s_stop,
_s_l_ext_hpr, _s_s_ext_hpr)
model_no_sl_hpr[w_i] = _w_hpr
min_w_eod_hpr_no_sl[w_i] = _min_w_eod_hpr
min_w_lb_hpr_no_sl[w_i] = _min_w_lb_hpr
l_port_no_sl[w_i] = _s_longs
s_port_no_sl[w_i] = _s_shorts
l_stops_no_sl[w_i] = _l_stops
s_stops_no_sl[w_i] = _s_stops
# calc eod model
_t_w_l_s_hpr_mean = np.mean(_t_w_l_s_hpr, axis=0)
_t_w_s_s_hpr_mean = np.mean(_t_w_s_s_hpr, axis=0)
_t_w_hpr = (_t_w_l_s_hpr_mean - _t_w_s_s_hpr_mean) / 2
sl_idxs = np.nonzero(_t_w_hpr <= get_config().STOP_LOSS_HPR)
_ext_idx = _default_ext_idx
_stop = False
if sl_idxs[0].shape[0] > 0:
_ext_idx = sl_idxs[0][0]
_stop = True
_s_l_ext_idx = np.full(_l_stocks.shape, _ext_idx)
_s_s_ext_idx = np.full(_s_stocks.shape, _ext_idx)
_s_l_stop = np.full(_l_stocks.shape, _stop)
_s_s_stop = np.full(_l_stocks.shape, _stop)
_s_l_ext_hpr = _t_w_l_s_hpr[:, _ext_idx]
_s_s_ext_hpr = _t_w_s_s_hpr[:, _ext_idx]
_l_hpr, _s_hpr, _w_hpr, _min_w_eod_hpr, _min_w_lb_hpr, _l_stops, _s_stops, _s_longs, _s_shorts, _min_to, _avg_to = calc_params(
False, _t_w_eods, _t_w_l_s_hpr, _t_w_s_s_hpr, _t_w_l_s_lb_hpr,
_t_w_s_s_lb_hpr, _s_l_ext_idx, _s_s_ext_idx, _s_l_stop, _s_s_stop,
_s_l_ext_hpr, _s_s_ext_hpr)
model_eod_sl_hpr[w_i] = _w_hpr
min_w_eod_hpr_eod_sl[w_i] = _min_w_eod_hpr
min_w_lb_hpr_eod_sl[w_i] = _min_w_lb_hpr
l_port_eod_sl[w_i] = _s_longs
s_port_eod_sl[w_i] = _s_shorts
l_stops_eod_sl[w_i] = _l_stops
s_stops_eod_sl[w_i] = _s_stops
# calc lower bound hpr
_t_w_l_s_lb_hpr_mean = np.mean(_t_w_l_s_lb_hpr, axis=0)
_t_w_s_s_lb_hpr_mean = np.mean(_t_w_s_s_lb_hpr, axis=0)
_t_w_lb_hpr = (_t_w_l_s_lb_hpr_mean - _t_w_s_s_lb_hpr_mean) / 2
_t_w_l_s_o_hpr_mean = np.mean(_t_w_l_s_o_hpr, axis=0)
_t_w_s_s_o_hpr_mean = np.mean(_t_w_s_s_o_hpr, axis=0)
_t_w_o_hpr = (_t_w_l_s_o_hpr_mean - _t_w_s_s_o_hpr_mean) / 2
sl_idxs = np.nonzero(_t_w_lb_hpr <= get_config().STOP_LOSS_HPR)
_ext_idx = _t_w_eod_num - 1
_stop = False
_stop_on_open = False
if sl_idxs[0].shape[0] > 0:
_ext_idx = sl_idxs[0][0]
_stop = True
if _t_w_o_hpr[_ext_idx] <= get_config().STOP_LOSS_HPR:
_stop_on_open = True
_s_l_ext_idx = np.full(_l_stocks.shape, _ext_idx)
_s_s_ext_idx = np.full(_s_stocks.shape, _ext_idx)
_s_l_stop = np.full(_l_stocks.shape, _stop)
_s_s_stop = np.full(_s_stocks.shape, _stop)
if _stop:
if _stop_on_open:
_s_l_ext_hpr = _t_w_l_s_o_hpr[:, _ext_idx]
_s_s_ext_hpr = _t_w_s_s_o_hpr[:, _ext_idx]
else:
_s_l_ext_hpr = np.full(_l_stocks.shape,
get_config().STOP_LOSS_HPR)
_s_s_ext_hpr = np.full(_s_stocks.shape,
-get_config().STOP_LOSS_HPR)
else:
_s_l_ext_hpr = _t_w_l_s_hpr[:, _ext_idx]
_s_s_ext_hpr = _t_w_s_s_hpr[:, _ext_idx]
_l_hpr, _s_hpr, _w_hpr, _min_w_eod_hpr, _min_w_lb_hpr, _l_stops, _s_stops, _s_longs, _s_shorts, _min_to, _avg_to = calc_params(
True, _t_w_eods, _t_w_l_s_hpr, _t_w_s_s_hpr, _t_w_l_s_lb_hpr,
_t_w_s_s_lb_hpr, _s_l_ext_idx, _s_s_ext_idx, _s_l_stop, _s_s_stop,
_s_l_ext_hpr, _s_s_ext_hpr)
model_lb_sl_hpr[w_i] = _w_hpr
min_w_eod_hpr_lb_sl[w_i] = _min_w_eod_hpr
min_w_lb_hpr_lb_sl[w_i] = _min_w_lb_hpr
l_port_lb_sl[w_i] = _s_longs
s_port_lb_sl[w_i] = _s_shorts
l_stops_lb_sl[w_i] = _l_stops
s_stops_lb_sl[w_i] = _s_stops
# calc sl by stock model
def first_true_idx_by_row(mask, default_idx):
idxs = np.full(mask.shape[0], default_idx)
for i, ele in enumerate(np.argmax(mask, axis=1)):
if ele == 0 and mask[i][0] == 0:
idxs[i] = default_idx
else:
idxs[i] = ele
return idxs
# _t_w_l_s_o_hpr = _t_w_s_s_o_hpr[sel_l_cond, :]
# _t_w_s_s_o_hpr = _t_w_s_s_o_hpr[sel_s_cond, :]
# long
_s_l_stop_mask = _t_w_l_s_lb_hpr <= get_config().STOP_LOSS_HPR
_s_l_stop = np.any(_s_l_stop_mask, axis=1)
_s_l_ext_idx = first_true_idx_by_row(_s_l_stop_mask, _default_ext_idx)
# by default ext hpr == hpr no sl
_s_l_ext_hpr = _t_w_l_s_hpr[:, _default_ext_idx]
# calc hpr for stocks with sl
# exit idx for stocks with sl
_s_l_sl_ext_idx = _s_l_ext_idx[_s_l_stop]
# stocks with sl hpr by open px during the week
_t_w_l_sl_s_o_hrp = _t_w_l_s_o_hpr[_s_l_stop, :]
_aaa = _t_w_l_sl_s_o_hrp
_xxx = np.arange(_aaa.shape[0])
_yyy = _s_l_sl_ext_idx
# hpr for stocks with sl by open px
_l_s_sl_o_hrp = _aaa[_xxx, _yyy]
# condition
_use_o_px = _l_s_sl_o_hrp <= get_config().STOP_LOSS_HPR
# stock with sl hpr
_s_l_sl_hpr = np.where(_use_o_px, _l_s_sl_o_hrp,
get_config().STOP_LOSS_HPR)
# override default hpr for stocks with sl
_s_l_ext_hpr[_s_l_stop] = _s_l_sl_hpr
# short
_s_s_stop_mask = _t_w_s_s_lb_hpr >= -get_config().STOP_LOSS_HPR
_s_s_stop = np.any(_s_s_stop_mask, axis=1)
_s_s_ext_idx = first_true_idx_by_row(_s_s_stop_mask, _default_ext_idx)
# by default ext hpr == hpr no sl
_s_s_ext_hpr = _t_w_s_s_hpr[:, _default_ext_idx]
# calc hpr for stocks with sl
# exit idx for stocks with sl
_s_s_sl_ext_idx = _s_s_ext_idx[_s_s_stop]
# stocks with sl hpr by open px during the week
_t_w_s_sl_s_o_hrp = _t_w_s_s_o_hpr[_s_s_stop, :]
_aaa = _t_w_s_sl_s_o_hrp
_xxx = np.arange(_aaa.shape[0])
_yyy = _s_s_sl_ext_idx
# hpr for stocks with sl by open px
_s_s_sl_o_hrp = _aaa[_xxx, _yyy]
# condition
_use_o_px = _s_s_sl_o_hrp >= -get_config().STOP_LOSS_HPR
# stock with sl hpr
_s_s_sl_hpr = np.where(_use_o_px, _s_s_sl_o_hrp,
-get_config().STOP_LOSS_HPR)
# override default hpr for stocks with sl
_s_s_ext_hpr[_s_s_stop] = _s_s_sl_hpr
_l_hpr, _s_hpr, _w_hpr, _min_w_eod_hpr, _min_w_lb_hpr, _l_stops, _s_stops, _s_longs, _s_shorts, _min_to, _avg_to = calc_params(
True, _t_w_eods, _t_w_l_s_hpr, _t_w_s_s_hpr, _t_w_l_s_lb_hpr,
_t_w_s_s_lb_hpr, _s_l_ext_idx, _s_s_ext_idx, _s_l_stop, _s_s_stop,
_s_l_ext_hpr, _s_s_ext_hpr)
model_s_sl_hpr[w_i] = _w_hpr
min_w_eod_hpr_s_sl[w_i] = _min_w_eod_hpr
min_w_lb_hpr_s_sl[w_i] = _min_w_lb_hpr
l_port_s_sl[w_i] = _s_longs
s_port_s_sl[w_i] = _s_shorts
l_stops_s_sl[w_i] = _l_stops
s_stops_s_sl[w_i] = _s_stops
model_no_sl = (model_no_sl_hpr, min_w_eod_hpr_no_sl,
min_w_lb_hpr_no_sl, l_stops_no_sl, s_stops_no_sl,
l_port_no_sl, s_port_no_sl)
model_eod_sl = (model_eod_sl_hpr, min_w_eod_hpr_eod_sl,
min_w_lb_hpr_eod_sl, l_stops_eod_sl, s_stops_eod_sl,
l_port_eod_sl, s_port_eod_sl)
model_lb_sl = (model_lb_sl_hpr, min_w_eod_hpr_lb_sl,
min_w_lb_hpr_lb_sl, l_stops_lb_sl, s_stops_lb_sl,
l_port_lb_sl, s_port_lb_sl)
model_s_sl = (model_s_sl_hpr, min_w_eod_hpr_s_sl, min_w_lb_hpr_s_sl,
l_stops_s_sl, s_stops_s_sl, l_port_s_sl, s_port_s_sl)
progress.print_progess_end()
return c_l, \
c_s, \
model_no_sl, \
model_eod_sl, \
model_lb_sl, \
model_s_sl, \
min_to, \
avg_to, \
longs, \
shorts, \
selection
TOTAL_DAYS = (get_config().HIST_END - get_config().HIST_BEG).days
curr_progress = 0
print('preprocessing data...')
while True:
# iterate over weeks
SUNDAY = SUNDAY + datetime.timedelta(days=7)
# DEBUG_DATE = datetime.datetime.strptime('2001-09-16', '%Y-%m-%d').date()
# if (SUNDAY == DEBUG_DATE):
# debug = 0
PASSED_DAYS = (SUNDAY - get_config().HIST_BEG).days
curr_progress = progress.print_progress(curr_progress, PASSED_DAYS,
TOTAL_DAYS)
# break when all availiable data processed
if SUNDAY > get_config().HIST_END:
break
w_r_i = get_dates_for_weekly_return(get_config().HIST_BEG,
get_config().HIST_END,
trading_day_mask, SUNDAY,
get_config().NUM_WEEKS + 1)
# continue if all data not availiable yet
if w_r_i is None:
continue
d_r_i = get_dates_for_daily_return(get_config().HIST_BEG,
get_config().HIST_END, trading_day_mask,
SUNDAY - datetime.timedelta(days=7),
get_config().NUM_DAYS)
# continue if all data not availiable yet
def train():
snp_env = SnpEnv()
if get_config().NET_VER == NetVersion.APPLE:
net = NetApple()
elif get_config().NET_VER == NetVersion.BANANA:
net = NetBanana()
elif get_config().NET_VER == NetVersion.WORM:
net = NetWorm()
elif get_config().NET_VER == NetVersion.SNAKE:
net = NetSnake()
elif get_config().NET_VER == NetVersion.ANTI_SNAKE:
net = NetAntiSnake()
elif get_config().NET_VER == NetVersion.CAT:
net = NetCat()
elif get_config().NET_VER == NetVersion.COW:
net = NetCow()
net.init()
train_trading_schedule = []
test_trading_schedule = []
for ent, ext in snp_env.trading_schedule_generator(
get_config().TRAIN_BEG,
get_config().TRAIN_END,
get_config().TRADING_PERIOD_DAYS):
train_trading_schedule.append((ent, ext))
for ent, ext in snp_env.trading_schedule_generator(
get_config().TEST_BEG,
get_config().TEST_END,
get_config().TRADING_PERIOD_DAYS):
test_trading_schedule.append((ent, ext))
if not os.path.exists(get_config().TRAIN_STAT_PATH):
with open(get_config().TRAIN_STAT_PATH, 'a', newline='') as f:
writer = csv.writer(f)
writer.writerow(
('epoch', 'train dd', 'train y avg', 'train sharpe', 'test dd',
'test y avg', 'test sharpe'))
with open(get_config().TRAIN_STAT_PATH, 'a', newline='') as f:
writer = csv.writer(f)
if get_config().EPOCH_WEIGHTS_TO_LOAD != 0:
net.load_weights(get_config().WEIGHTS_PATH,
get_config().EPOCH_WEIGHTS_TO_LOAD)
epoch = get_config().EPOCH_WEIGHTS_TO_LOAD
if get_config().MODE == Mode.TRAIN:
epoch += 1
else:
epoch = 0
while True:
print("Epoch %d" % epoch)
# train
if get_config().MODE == Mode.TRAIN:
print("Training...")
if get_config().SHUFFLE:
train_schedule = random.sample(train_trading_schedule,
len(train_trading_schedule))
else:
train_schedule = train_trading_schedule
dataset_size = len(train_schedule)
curr_progress = 0
passed = 0
for ent, ext in train_schedule:
stk_mask = snp_env.get_tradeable_snp_components_mask(ent)
# print("%d %s %s" % (np.sum(stk_mask), ent.strftime("%Y-%m-%d"), ext.strftime("%Y-%m-%d")))
x = snp_env.get_input(stk_mask, ent)
labels = snp_env.get_ret_lbl(stk_mask, ent, ext)
if get_config().NET_VER == NetVersion.COW:
variances = calc_variance(x)
if get_config().NET_VER == NetVersion.COW:
net.fit(x, labels, variances)
else:
net.fit(x, labels)
if passed == 0:
if get_config().NET_VER == NetVersion.COW:
pl, weights = net.eval(x, labels, variances)
else:
pl, weights = net.eval(x, labels)
print(pl)
curr_progress = progress.print_progress(
curr_progress, passed, dataset_size)
passed += 1
progress.print_progess_end()
# eval train
print("Eval train...")
ret = np.zeros((len(train_trading_schedule)))
dataset_size = len(train_trading_schedule)
curr_progress = 0
passed = 0
dt = []
for ent, ext in train_trading_schedule:
if ext is None:
break
if len(dt) == 0:
dt.append(ent)
dt.append(ext)
stk_mask = snp_env.get_tradeable_snp_components_mask(ent)
x = snp_env.get_input(stk_mask, ent)
labels = snp_env.get_ret_lbl(stk_mask, ent, ext)
if get_config().NET_VER == NetVersion.COW:
variances = calc_variance(x)
pl, weights = net.eval(x, labels, variances)
else:
pl, weights = net.eval(x, labels)
if get_config().NET_VER == NetVersion.APPLE:
# # net
# long_mask = weights >= 0.0
# short_mask = weights <= 0.0
#
# int_date = snp_env.find_trading_date(ent + datetime.timedelta(days=1))
# int_r = snp_env.get_ret_lbl(stk_mask, ent, int_date)
# port_ret = labels - int_r
# # sorted_int_r_idxs = np.argsort(int_r)
# long_idxs = np.nonzero(long_mask)[0]
# long_int_r = int_r[long_idxs]
# sorted_long_int_r_idxs = np.argsort(long_int_r)
# long_sel_idxs = long_idxs[sorted_long_int_r_idxs[:get_config().SELECTTION]]
#
# short_idxs = np.nonzero(short_mask)[0]
# short_int_r = int_r[short_idxs]
# sorted_short_int_r_idxs = np.argsort(short_int_r)
# short_sel_idxs = short_idxs[sorted_short_int_r_idxs[-get_config().SELECTTION:]]
#
# long_pl = np.mean(port_ret[long_sel_idxs])
# short_pl = np.mean(port_ret[short_sel_idxs])
# # no net
# int_date = snp_env.find_trading_date(ent + datetime.timedelta(days=1))
# int_r = snp_env.get_ret_lbl(stk_mask, ent, int_date)
# port_ret = labels - int_r
# sorted_int_r_idxs = np.argsort(int_r)
# long_pl = np.mean(port_ret[sorted_int_r_idxs[:get_config().SELECTTION]])
# short_pl = np.mean(port_ret[sorted_int_r_idxs[-get_config().SELECTTION:]])
# 1d no net
prev_date = snp_env.find_prev_trading_date(
ent - datetime.timedelta(days=1))
int_stk_mask = snp_env.get_tradeable_snp_components_mask(
prev_date)
stk_mask &= int_stk_mask
int_r = snp_env.get_ret_lbl(stk_mask, prev_date, ent)
port_ret = snp_env.get_ret_lbl(stk_mask, ent, ext)
sorted_int_r_idxs = np.argsort(int_r)
long_pl = np.mean(
port_ret[sorted_int_r_idxs[:get_config().SELECTTION]])
short_pl = np.mean(
port_ret[sorted_int_r_idxs[-get_config().SELECTTION:]])
# real_ext = snp_env.find_trading_date(ext + datetime.timedelta(days=1))
# if real_ext is None:
# real_ext = ext
# int_r = labels
# port_ret = snp_env.get_ret_lbl(stk_mask, ext, real_ext)
# sorted_int_r_idxs = np.argsort(int_r)
# long_pl = np.mean(port_ret[sorted_int_r_idxs[:get_config().SELECTTION]])
# short_pl = np.mean(port_ret[sorted_int_r_idxs[-get_config().SELECTTION:]])
pl = 0.7 * long_pl - 0.3 * short_pl
# if get_config().NET_VER == NetVersion.SNAKE or get_config().NET_VER == NetVersion.ANTI_SNAKE:
# sorted_weights_idxs = np.argsort(weights)
# selected_weights_idxs = sorted_weights_idxs[-get_config().SELECTTION:]
# pl = np.mean(labels[selected_weights_idxs])
# if get_config().NET_VER == NetVersion.ANTI_SNAKE:
# pl = -pl
if get_config().PRINT_PREDICTION:
print_alloc(pl, ent, snp_env.tickers, stk_mask, weights)
if abs(pl) >= 0.3:
pl = 0
ret[passed] = pl
curr_progress = progress.print_progress(
curr_progress, passed, dataset_size)
passed += 1
progress.print_progess_end()
# print("Train loss: %.4f" % (np.mean(np.sqrt(ret)) * 100))
years = (get_config().TRAIN_END -
get_config().TRAIN_BEG).days / 365
capital = get_capital(ret, False)
train_dd = get_draw_down(capital, False)
train_sharpe = get_sharpe_ratio(ret, years)
train_y_avg = get_avg_yeat_ret(ret, years)
print('Train dd: %.2f%% y_avg: %.2f%% sharpe: %.2f' %
(train_dd * 100, train_y_avg * 100, train_sharpe))
if get_config().MODE == Mode.TEST:
plot_equity_curve("Train equity curve", dt, capital)
df = pd.DataFrame({'date': dt, 'capital': capital})
df.to_csv('data/tr_eq.csv', index=False)
# eval test
print("Eval test...")
ret = np.zeros((len(test_trading_schedule)))
dataset_size = len(test_trading_schedule)
curr_progress = 0
passed = 0
dt = []
for ent, ext in test_trading_schedule:
if ext.month == 3 and ext.day == 11 and ext.year == 2015:
_debug = 0
if ext is None:
break
if len(dt) == 0:
dt.append(ent)
dt.append(ext)
stk_mask = snp_env.get_tradeable_snp_components_mask(ent)
x = snp_env.get_input(stk_mask, ent)
labels = snp_env.get_ret_lbl(stk_mask, ent, ext)
if get_config().NET_VER == NetVersion.COW:
variances = calc_variance(x)
pl, weights = net.eval(x, labels, variances)
else:
pl, weights = net.eval(x, labels)
if get_config().NET_VER == NetVersion.APPLE:
# # net
# long_mask = weights >= 0.0
# short_mask = weights <= 0.0
#
# int_date = snp_env.find_trading_date(ent + datetime.timedelta(days=1))
# int_r = snp_env.get_ret_lbl(stk_mask, ent, int_date)
# port_ret = labels - int_r
# # sorted_int_r_idxs = np.argsort(int_r)
# long_idxs = np.nonzero(long_mask)[0]
# long_int_r = int_r[long_idxs]
# sorted_long_int_r_idxs = np.argsort(long_int_r)
# long_sel_idxs = long_idxs[sorted_long_int_r_idxs[:get_config().SELECTTION]]
#
# short_idxs = np.nonzero(short_mask)[0]
# short_int_r = int_r[short_idxs]
# sorted_short_int_r_idxs = np.argsort(short_int_r)
# short_sel_idxs = short_idxs[sorted_short_int_r_idxs[-get_config().SELECTTION:]]
#
# long_pl = np.mean(port_ret[long_sel_idxs])
# short_pl = np.mean(port_ret[short_sel_idxs])
# # no net
# int_date = snp_env.find_trading_date(ent + datetime.timedelta(days=1))
# int_r = snp_env.get_ret_lbl(stk_mask, ent, int_date)
# port_ret = labels - int_r
# sorted_int_r_idxs = np.argsort(int_r)
# long_pl = np.mean(port_ret[sorted_int_r_idxs[:get_config().SELECTTION]])
# short_pl = np.mean(port_ret[sorted_int_r_idxs[-get_config().SELECTTION:]])
# 1d no net
prev_date = snp_env.find_prev_trading_date(
ent - datetime.timedelta(days=1))
int_stk_mask = snp_env.get_tradeable_snp_components_mask(
prev_date)
stk_mask &= int_stk_mask
int_r = snp_env.get_ret_lbl(stk_mask, prev_date, ent)
port_ret = snp_env.get_ret_lbl(stk_mask, ent, ext)
sorted_int_r_idxs = np.argsort(int_r)
long_pl = np.mean(
port_ret[sorted_int_r_idxs[:get_config().SELECTTION]])
short_pl = np.mean(
port_ret[sorted_int_r_idxs[-get_config().SELECTTION:]])
pl = 0.7 * long_pl - 0.3 * short_pl
# if get_config().NET_VER == NetVersion.SNAKE or get_config().NET_VER == NetVersion.ANTI_SNAKE:
# sorted_weights_idxs = np.argsort(weights)
# selected_weights_idxs = sorted_weights_idxs[-get_config().SELECTTION:]
# pl = np.mean(labels[selected_weights_idxs])
# if get_config().NET_VER == NetVersion.ANTI_SNAKE:
# pl = -pl
if get_config().PRINT_PREDICTION:
print_alloc(pl, ent, snp_env.tickers, stk_mask, weights)
if abs(pl) >= 0.3:
pl = 0
ret[passed] = pl
curr_progress = progress.print_progress(
curr_progress, passed, dataset_size)
passed += 1
progress.print_progess_end()
# print("Test loss: %.4f" % (np.mean(np.sqrt(ret)) * 100))
years = (get_config().TRAIN_END -
get_config().TRAIN_BEG).days / 365
capital = get_capital(ret, False)
test_dd = get_draw_down(capital, False)
test_sharpe = get_sharpe_ratio(ret, years)
test_y_avg = get_avg_yeat_ret(ret, years)
print('Test dd: %.2f%% y_avg: %.2f%% sharpe: %.2f' %
(test_dd * 100, test_y_avg * 100, test_sharpe))
if get_config().MODE == Mode.TEST:
plot_equity_curve("Test equity curve", dt, capital)
df = pd.DataFrame({'date': dt, 'capital': capital})
df.to_csv('data/tst_eq.csv', index=False)
if get_config().MODE == Mode.TRAIN:
net.save_weights(get_config().WEIGHTS_PATH, epoch)
writer.writerow((epoch, train_dd, train_y_avg, train_sharpe,
test_dd, test_y_avg, test_sharpe))
epoch += 1
f.flush()
else:
show_plots()
break
etf_names.append(text)
hit = False
print(len(isin_list), len(etf_names))
kombi = zip(isin_list, etf_names)
kombi_set = set(kombi)
for eintrag in kombi_set:
isin, name = eintrag
print(f'{isin};{name}')
# Lade die Kurse für die ISIN Liste herunter.
# Die Kurse werden pro ISIN abgespeichert.
current_isin_count = 0
max_isin = len(isin_list)
print('Lade ETF Kurse:')
for isin in isin_list:
progress.print_progress(current_isin_count, max_isin)
current_isin_count += 1
etf_kurse = requests.get(f'https://de.extraetf.com/api-v2/chart/?isin={isin}¤cy_id=2')
parsed = json.loads(etf_kurse.text)
results = parsed['results']
for result, kurse in results.items():
if result == 'trinav':
print(f'Kurse für {isin} werden gespeichert')
pickle.dump( kurse, open( f'{isin}.p', "wb" ) )
time.sleep(5)
def __init__(self, alpha):
print_progress('Using FiltDoubleBackpropLoss at %e' % alpha)
self.alpha = alpha
def main():
parser = argparse.ArgumentParser(description='Adversarial test')
parser.add_argument('--expdir',
type=str,
default='experiment/resnet',
help='experiment directory containing model')
args = parser.parse_args()
progress = default_progress()
experiment_dir = args.expdir
perturbations = [
numpy.zeros((224, 224, 3), dtype='float32'),
numpy.load('perturbation/VGG-19.npy'),
numpy.load('perturbation/perturb_synth.npy'),
numpy.load('perturbation/perturb_synth_histmatch.npy'),
numpy.load('perturbation/perturb_synth_newspectrum.npy'),
numpy.load('perturbation/perturbation_rotated.npy'),
numpy.load('perturbation/perturbation_rotated_averaged.npy'),
numpy.load('perturbation/perturbation_noisefree.npy'),
numpy.load('perturbation/perturbation_noisefree_nodc.npy'),
]
perturbation_name = [
"unattacked",
"universal adversary",
"synthetic",
"histmatch",
"newspectrum",
"rotated",
"rotated_averaged",
"noisefree",
"noisefree_nodc",
]
print('Original std %e new std %e' %
(numpy.std(perturbations[1]), numpy.std(perturbations[2])))
perturbations[2] *= (numpy.std(perturbations[1]) /
numpy.std(perturbations[2]))
# To deaturate uncomment.
loaders = [
torch.utils.data.DataLoader(
CachedImageFolder(
'dataset/miniplaces/simple/val',
transform=transforms.Compose([
transforms.Resize(128),
# transforms.CenterCrop(112),
AddPerturbation(perturbation[40:168, 40:168]),
transforms.ToTensor(),
transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV),
])),
batch_size=32,
shuffle=False,
num_workers=0,
pin_memory=True) for perturbation in perturbations
]
# Create a simplified ResNet with half resolution.
model = CustomResNet(18, num_classes=100, halfsize=True)
layernames = ['relu', 'layer1', 'layer2', 'layer3', 'layer4', 'fc']
retain_layers(model, layernames)
checkpoint_filename = 'best_miniplaces.pth.tar'
best_checkpoint = os.path.join(experiment_dir, checkpoint_filename)
checkpoint = torch.load(best_checkpoint)
iter_num = checkpoint['iter']
model.load_state_dict(checkpoint['state_dict'])
model.eval()
model.cuda()
criterion = nn.CrossEntropyLoss().cuda()
val_acc = [AverageMeter() for _ in loaders]
diffs, maxdiffs, signflips = [
[defaultdict(AverageMeter) for _ in perturbations] for _ in [1, 2, 3]
]
for all_batches in progress(zip(*loaders), total=len(loaders[0])):
# Load data
indata = [b[0].cuda() for b in all_batches]
target = all_batches[0][1].cuda()
# Evaluate model
retained = defaultdict(list)
with torch.no_grad():
for i, inp in enumerate(indata):
output = model(inp)
_, pred = output.max(1)
accuracy = (
target.eq(pred)).data.float().sum().item() / inp.size(0)
val_acc[i].update(accuracy, inp.size(0))
for layer, data in model.retained.items():
retained[layer].append(data)
for layer, vals in retained.items():
for i in range(1, len(indata)):
diffs[i][layer].update(
(vals[i] - vals[0]).pow(2).mean().item(), len(target))
maxdiffs[i][layer].update(
(vals[i] - vals[0]).view(len(target),
-1).max(1)[0].mean().item(),
len(target))
signflips[i][layer].update(
((vals[i] > 0).float() -
(vals[0] > 0).float()).abs().mean().item(), len(target))
# Check accuracy
post_progress(a=val_acc[0].avg)
# Report on findings
for i, acc in enumerate(val_acc):
print_progress('Test #%d (%s), validation accuracy %.4f' %
(i, perturbation_name[i], acc.avg))
if i > 0:
for layer in layernames:
print_progress(
'Layer %s RMS diff %.3e maxdiff %.3e signflip %.3e' %
(layer, math.sqrt(diffs[i][layer].avg),
maxdiffs[i][layer].avg, signflips[i][layer].avg))
def train(net):
create_folders()
env = Env()
if not os.path.exists(get_config().TRAIN_STAT_PATH):
with open(get_config().TRAIN_STAT_PATH, 'a', newline='') as f:
writer = csv.writer(f)
writer.writerow((
'epoch',
'train loss',
'test loss',
))
tickers_to_plot = [get_config().TICKER]
total = len(tickers_to_plot)
ticker_to_plot_idxs = np.zeros((total), dtype=np.int32)
for i in range(total):
ticker_to_plot_idxs[i] = env._ticker_to_idx(tickers_to_plot[i])
def open_train_stat_file():
return open(get_config().TRAIN_STAT_PATH, 'a', newline='')
def is_train():
return get_config().MODE == Mode.TRAIN
with open_train_stat_file() if is_train() else dummy_context_mgr() as f:
if is_train():
writer = csv.writer(f)
if get_config().EPOCH_WEIGHTS_TO_LOAD != 0:
net.load_weights(get_config().WEIGHTS_PATH,
get_config().EPOCH_WEIGHTS_TO_LOAD)
epoch = get_config().EPOCH_WEIGHTS_TO_LOAD
if is_train():
epoch += 1
else:
net.init()
epoch = 0
def get_net_data(BEG, END):
beg_idx = env.get_next_trading_day_data_idx(BEG)
end_idx = env.get_prev_trading_day_data_idx(END)
raw_dates = env.get_raw_dates(beg_idx, end_idx)
input = env.get_input(beg_idx, end_idx)
px = env.get_adj_close_px(beg_idx, end_idx)
px_pred_hor = env.get_adj_close_px(
beg_idx + get_config().PRED_HORIZON,
end_idx + get_config().PRED_HORIZON)
px_t1 = env.get_adj_close_px(beg_idx + 1, end_idx + 1)
ds_sz = px_pred_hor.shape[1]
raw_dates = raw_dates[:ds_sz]
input = input[:, :ds_sz, :]
px = px[:, :ds_sz]
px_t1 = px_t1[:, :ds_sz]
labels = (px_pred_hor - px) / px
rets = (px_t1 - px) / px
batch_num = get_batches_num(ds_sz, get_config().BPTT_STEPS)
return ds_sz, batch_num, raw_dates, px, input, labels, rets
tr_ds_sz, tr_batch_num, tr_raw_dates, tr_px, tr_input, tr_labels, tr_rets = get_net_data(
get_config().TRAIN_BEG,
get_config().TRAIN_END)
tst_ds_sz, tst_batch_num, tst_raw_dates, tst_px, tst_input, tst_labels, tst_rets = get_net_data(
get_config().TEST_BEG,
get_config().TEST_END)
if get_config().DRAW_PREDICTIONS:
tr_pred_px_series = []
tr_pred_dt_series = []
tst_pred_px_series = []
tst_pred_dt_series = []
tr_eq = np.zeros((total, tr_ds_sz))
tst_eq = np.zeros((total, tst_ds_sz))
def get_batch_input_and_lables(input, labels, b):
b_i = b * get_config().BPTT_STEPS
e_i = (b + 1) * get_config().BPTT_STEPS
return input[:, b_i:e_i, :], labels[:, b_i:e_i]
def predict_price_series(px, raw_dates, predictions, b, pred_px,
pred_dt, pred_px_series, pred_dt_series,
curr_pred_px):
for i in range(predictions.shape[1]):
data_idx = b * get_config().BPTT_STEPS + i
serie_idx = data_idx % get_config().RESET_PRED_PX_EACH_N_DAYS
if serie_idx == 0:
# finish old serie is exists
if pred_px is not None:
pred_px[ticker_to_plot_idxs,
get_config().
RESET_PRED_PX_EACH_N_DAYS] = curr_pred_px
pred_dt[get_config(
).RESET_PRED_PX_EACH_N_DAYS] = date_from_timestamp(
raw_dates[data_idx])
pred_px_series.append(pred_px)
pred_dt_series.append(pred_dt)
# reset price
curr_pred_px = px[ticker_to_plot_idxs, data_idx]
# create new serie
pred_px = np.zeros(
(total, get_config().RESET_PRED_PX_EACH_N_DAYS + 1))
pred_dt = [None
] * (get_config().RESET_PRED_PX_EACH_N_DAYS + 1)
# fill values
pred_px[ticker_to_plot_idxs, serie_idx] = curr_pred_px
pred_dt[serie_idx] = date_from_timestamp(raw_dates[data_idx])
# update pred px
curr_pred_px += (predictions[ticker_to_plot_idxs, i, 0] /
get_config().PRED_HORIZON) * curr_pred_px
return curr_pred_px, pred_px, pred_dt
def fill_eq(eq, rets, raw_dates):
nonlocal capital, bet, position
if capital is None:
capital = np.ones(total, dtype=np.float32)
if bet is None:
bet = np.zeros(total, dtype=np.float32)
if position is None:
position = 0
for i in range(predictions.shape[1]):
data_idx = b * get_config().BPTT_STEPS + i
date = date_from_timestamp(raw_dates[data_idx])
if date.year == 2012 and date.month == 12 and date.day == 31:
_debug = 0
if data_idx % get_config().REBALANCE_FREQ == 0:
position = np.sign(predictions[ticker_to_plot_idxs, i, 0])
capital += bet
bet = np.ones(total)
capital -= bet
eq[ticker_to_plot_idxs, data_idx] = (capital + bet)
bet += bet * rets[ticker_to_plot_idxs, data_idx] * position
while epoch <= get_config().MAX_EPOCH:
print("Eval %d epoch on train set..." % epoch)
curr_progress = 0
state = None
losses = np.zeros((tr_batch_num))
curr_pred_px = None
pred_px = None
pred_dt = None
capital = None
bet = None
position = None
for b in range(tr_batch_num):
if state is None:
state = net.zero_state(len(env.tickers))
input, labels = get_batch_input_and_lables(
tr_input, tr_labels, b)
state, loss, predictions = net.eval(state, input, labels)
if get_config().DRAW_PREDICTIONS:
curr_pred_px, pred_px, pred_dt = predict_price_series(
tr_px, tr_raw_dates, predictions, b, pred_px, pred_dt,
tr_pred_px_series, tr_pred_dt_series, curr_pred_px)
fill_eq(tr_eq, tr_rets, tr_raw_dates)
losses[b] = loss
curr_progress = progress.print_progress(
curr_progress, b, tr_batch_num)
progress.print_progess_end()
train_avg_loss = np.mean(np.sqrt(losses))
print("Train loss: %.4f%%" % (train_avg_loss * 100))
print("Eval %d epoch on test set..." % epoch)
curr_progress = 0
state = None
losses = np.zeros((tst_batch_num))
curr_pred_px = None
pred_px = None
pred_dt = None
capital = None
bet = None
position = None
for b in range(tst_batch_num):
if state is None:
state = net.zero_state(len(env.tickers))
input, labels = get_batch_input_and_lables(
tst_input, tst_labels, b)
state, loss, predictions = net.eval(state, input, labels)
if get_config().DRAW_PREDICTIONS:
curr_pred_px, pred_px, pred_dt = predict_price_series(
tst_px, tst_raw_dates, predictions, b, pred_px,
pred_dt, tst_pred_px_series, tst_pred_dt_series,
curr_pred_px)
fill_eq(tst_eq, tst_rets, tst_raw_dates)
losses[b] = loss
curr_progress = progress.print_progress(
curr_progress, b, tst_batch_num)
progress.print_progess_end()
tst_avg_loss = np.mean(np.sqrt(losses))
print("Test loss: %.4f%%" % (tst_avg_loss * 100))
# draw plots in test mode and break
if not is_train():
dt = build_time_axis(tr_raw_dates)
if get_config().DRAW_PREDICTIONS:
plot_prediction('Train', dt, tr_px, tr_pred_px_series,
tr_pred_dt_series)
plot_eq('Train',
get_config().TRAIN_BEG,
get_config().TRAIN_END, dt, tr_eq)
dt = build_time_axis(tst_raw_dates)
if get_config().DRAW_PREDICTIONS:
plot_prediction('Test', dt, tst_px, tst_pred_px_series,
tst_pred_dt_series)
plot_eq('Test',
get_config().TEST_BEG,
get_config().TEST_END, dt, tst_eq)
show_plots()
break
# train
if is_train() and epoch <= get_config().MAX_EPOCH:
# save train progress
writer.writerow((epoch, train_avg_loss, tst_avg_loss))
f.flush()
# plot and save graphs
dt = build_time_axis(tr_raw_dates)
fig = plot_eq('Train',
get_config().TRAIN_BEG,
get_config().TRAIN_END, dt, tr_eq)
fig.savefig('%s/%04d.png' %
(get_config().TRAIN_FIG_PATH, epoch))
plt.close(fig)
if epoch == get_config().MAX_EPOCH:
tr_df = pd.DataFrame({'date': dt, 'capital': tr_eq[0, :]})
tr_df.to_csv(get_config().TRAIN_EQ_PATH, index=False)
dt = build_time_axis(tst_raw_dates)
fig = plot_eq('Test',
get_config().TEST_BEG,
get_config().TEST_END, dt, tst_eq)
fig.savefig('%s/%04d.png' %
(get_config().TEST_FIG_PATH, epoch))
plt.close(fig)
if epoch == get_config().MAX_EPOCH:
tr_df = pd.DataFrame({'date': dt, 'capital': tst_eq[0, :]})
tr_df.to_csv(get_config().TEST_EQ_PATH, index=False)
epoch += 1
if epoch > get_config().MAX_EPOCH:
break
print("Training %d epoch..." % epoch)
curr_progress = 0
state = None
for b in range(tr_batch_num):
if state is None:
state = net.zero_state(len(env.tickers))
input, labels = get_batch_input_and_lables(
tr_input, tr_labels, b)
state, loss, predictions = net.fit(state, input, labels)
curr_progress = progress.print_progress(
curr_progress, b, tr_batch_num)
progress.print_progess_end()
net.save_weights(get_config().WEIGHTS_PATH, epoch)
def train_ffnn(dr, wr, c_l, c_s, w_data_index, w_num_stocks, tr_beg_idx,
tr_end_idx, tr_wk_beg_idx, tr_wk_end_idx):
if not TRAIN_FFNN:
return
ffnn = ffnn_instance()
print("Training FFNN")
if LOAD_AU_WEIGHTS:
ffnn.load_au_weights('./rbm/au.chp', ['rbmw1', 'rbmhb1'], 0)
ffnn.load_au_weights('./rbm/au.chp', ['rbmw2', 'rbmhb2'], 1)
if ALIGN_BATCH_TO_DATA:
batches_per_epoch = tr_wk_end_idx - tr_wk_beg_idx
w_data_index = w_data_index[tr_wk_beg_idx:tr_wk_end_idx]
w_num_stocks = w_num_stocks[tr_wk_beg_idx:tr_wk_end_idx]
for i in range(FFNN_EPOCH_TO_TRAIN):
epoch_cost = 0.
curr_progress = 0
for b in range(batches_per_epoch):
s_i = w_data_index[b]
e_i = s_i + w_num_stocks[b]
_wr = wr[s_i:e_i, :]
_dr = dr[s_i:e_i, :]
input = np.concatenate([_wr, _dr], axis=1)
_cl = c_l[s_i:e_i].reshape((-1, 1))
_cs = c_s[s_i:e_i].reshape((-1, 1))
observation = np.concatenate([_cl, _cs],
axis=1).astype(np.float32)
cost = ffnn.partial_fit(input, observation)
# print("Batch cost: {:.3f}".format(cost))
epoch_cost += cost
curr_progress = progress.print_progress(
curr_progress, b, batches_per_epoch)
progress.print_progess_end()
print(" Epoch {} cost: {:.6f}".format(
i, epoch_cost / batches_per_epoch))
if i % SAVE_EACH_N_EPOCHS == 0:
print("Model saved")
ffnn.save_weights('./rbm/ffnn.chp')
else:
train_records = tr_end_idx - tr_beg_idx
dr = dr[tr_beg_idx:tr_end_idx]
wr = wr[tr_beg_idx:tr_end_idx]
data_indices = np.arange(train_records)
batches_per_epoch = train_records // FFNN_BATCH_SIZE
for i in range(FFNN_EPOCH_TO_TRAIN):
np.random.shuffle(data_indices)
epoch_cost = 0.
curr_progress = 0
for b in range(batches_per_epoch):
# get data indices for slice
d_i_s = data_indices[b * FFNN_BATCH_SIZE:(b + 1) *
FFNN_BATCH_SIZE]
_wr = wr[d_i_s, :]
_dr = dr[d_i_s, :]
input = np.concatenate([_wr, _dr], axis=1)
_cl = c_l[d_i_s].reshape((-1, 1))
_cs = c_s[d_i_s].reshape((-1, 1))
observation = np.concatenate([_cl, _cs],
axis=1).astype(np.float32)
cost = ffnn.partial_fit(input, observation)
# print("Batch cost: {:.3f}".format(cost))
epoch_cost += cost
curr_progress = progress.print_progress(
curr_progress, b, batches_per_epoch)
progress.print_progess_end()
print(" Epoch {} cost: {:.6f}".format(
i, epoch_cost / batches_per_epoch))
if i % SAVE_EACH_N_EPOCHS == 0:
print("Model saved")
ffnn.save_weights('./rbm/ffnn.chp')
ffnn.save_weights('./rbm/ffnn.chp')
print("Model saved")
avg_total_rew = []
for i, agent in enumerate(agents):
rewards = np.empty([N, steps])
actions = np.empty([N, steps])
total_rewards = np.empty([N, steps])
# We sample the agent N times.
for j in range(N):
metrics = agent.run_session(steps)
rewards[j] = metrics["R"]
A = metrics["A"]
actions[j] = A == np.argmax(agent.q)
total_rewards[j] = metrics["total_reward"]
prog.print_progress(j + 1,
N,
bar_length=50,
prefix="Agent " + str(i))
# Let's calculate the metrics presented above.
avg_rew.append(sum(rewards) / N)
opt_act.append(sum(actions) * 100 / N)
avg_total_rew.append(sum(total_rewards) / N)
import matplotlib.pyplot as plt
for A in avg_rew:
plt.plot(A)
plt.show()
for O in opt_act:
plt.plot(O)
def main():
progress = default_progress()
experiment_dir = 'experiment/positive_resnet'
# Here's our data
train_loader = torch.utils.data.DataLoader(CachedImageFolder(
'dataset/miniplaces/simple/train',
transform=transforms.Compose([
transforms.Resize(128),
transforms.RandomCrop(112),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV),
])),
batch_size=32,
shuffle=True,
num_workers=24,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(
CachedImageFolder(
'dataset/miniplaces/simple/val',
transform=transforms.Compose([
transforms.Resize(128),
# transforms.CenterCrop(112),
transforms.ToTensor(),
transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV),
])),
batch_size=32,
shuffle=False,
num_workers=24,
pin_memory=True)
# Create a simplified ResNet with half resolution.
model = CustomResNet(18, num_classes=100, halfsize=True)
checkpoint_filename = 'best_miniplaces.pth.tar'
best_checkpoint = os.path.join('experiment/resnet', checkpoint_filename)
checkpoint = torch.load(best_checkpoint)
model.load_state_dict(checkpoint['state_dict'])
model.train()
model.cuda()
# An abbreviated training schedule: 40000 batches.
# TODO: tune these hyperparameters.
# init_lr = 0.002
init_lr = 1e-4
# max_iter = 40000 - 34.5% @1
# max_iter = 50000 - 37% @1
# max_iter = 80000 - 39.7% @1
# max_iter = 100000 - 40.1% @1
max_iter = 50000
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.Adam(model.parameters())
iter_num = 0
best = dict(val_accuracy=0.0)
model.train()
# Oh, hold on. Let's actually resume training if we already have a model.
checkpoint_filename = 'miniplaces.pth.tar'
best_filename = 'best_%s' % checkpoint_filename
best_checkpoint = os.path.join(experiment_dir, best_filename)
try_to_resume_training = False
if try_to_resume_training and os.path.exists(best_checkpoint):
checkpoint = torch.load(os.path.join(experiment_dir, best_filename))
iter_num = checkpoint['iter']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
best['val_accuracy'] = checkpoint['accuracy']
def save_checkpoint(state, is_best):
filename = os.path.join(experiment_dir, checkpoint_filename)
ensure_dir_for(filename)
torch.save(state, filename)
if is_best:
shutil.copyfile(filename,
os.path.join(experiment_dir, best_filename))
def validate_and_checkpoint():
model.eval()
val_loss, val_acc = AverageMeter(), AverageMeter()
for input, target in progress(val_loader):
# Load data
input_var, target_var = [d.cuda() for d in [input, target]]
# Evaluate model
with torch.no_grad():
output = model(input_var)
loss = criterion(output, target_var)
_, pred = output.max(1)
accuracy = (target_var.eq(pred)
).data.float().sum().item() / input.size(0)
val_loss.update(loss.data.item(), input.size(0))
val_acc.update(accuracy, input.size(0))
# Check accuracy
post_progress(l=val_loss.avg, a=val_acc.avg)
# Save checkpoint
save_checkpoint(
{
'iter': iter_num,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'accuracy': val_acc.avg,
'loss': val_loss.avg,
}, val_acc.avg > best['val_accuracy'])
best['val_accuracy'] = max(val_acc.avg, best['val_accuracy'])
print_progress('Iteration %d val accuracy %.2f' %
(iter_num, val_acc.avg * 100.0))
# Here is our training loop.
while iter_num < max_iter:
for input, target in progress(train_loader):
if iter_num % 1000 == 0:
# Every 1000 turns chop down the negative params
neg_means = []
pos_means = []
neg_count = 0
param_count = 0
with torch.no_grad():
for name, param in model.named_parameters():
if all(n in name
for n in ['layer4', 'conv', 'weight']):
pc = param.numel()
neg = (param < 0)
nc = neg.int().sum().item()
param_count += pc
neg_count += nc
if nc > 0:
neg_means.append(param[neg].mean().item())
if nc < pc:
pos_means.append(param[~neg].mean().item())
param[neg] *= 0.5
print_progress(
'%d/%d neg, mean %e vs %e pos' %
(neg_count, param_count, sum(neg_means) /
len(neg_means), sum(pos_means) / len(pos_means)))
# Track the average training loss/accuracy for each epoch.
train_loss, train_acc = AverageMeter(), AverageMeter()
# Load data
input_var, target_var = [d.cuda() for d in [input, target]]
# Evaluate model
output = model(input_var)
loss = criterion(output, target_var)
train_loss.update(loss.data.item(), input.size(0))
# Perform one step of SGD
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Also check training set accuracy
_, pred = output.max(1)
accuracy = (target_var.eq(pred)).data.float().sum().item() / (
input.size(0))
train_acc.update(accuracy)
remaining = 1 - iter_num / float(max_iter)
post_progress(l=train_loss.avg,
a=train_acc.avg,
v=best['val_accuracy'])
# Advance
iter_num += 1
if iter_num >= max_iter:
break
# Linear learning rate decay
lr = init_lr * remaining
for param_group in optimizer.param_groups:
param_group['lr'] = lr
# Ocassionally check validation set accuracy and checkpoint
if iter_num % 1000 == 0:
validate_and_checkpoint()
model.train()
def eval():
nonlocal raw_dates, beg_data_idx, ds_size, batch_num, input, labels, px, mask, port_mask, eq, pred_hist, state
curr_progress = 0
cash = 1
pos = np.zeros((total_tickers))
pos_px = np.zeros((total_tickers))
losses = np.zeros((batch_num))
for b in range(batch_num):
if state is None:
state = net.zero_state(total_tickers)
b_b_i, b_e_i = get_batch_range(b)
_input = input[:, b_b_i:b_e_i, :]
_labels = labels[:, b_b_i:b_e_i]
_mask = mask[:, b_b_i:b_e_i]
state, loss, predictions = net.eval(
state, _input, _labels, _mask.astype(np.float32))
pred_hist[:, b_b_i:b_e_i] = predictions[:, :, 0]
for i in range(predictions.shape[1]):
data_idx = b * get_config().BPTT_STEPS + i
curr_px = px[:, data_idx]
global_data_idx = beg_data_idx + data_idx
date = datetime.datetime.fromtimestamp(
raw_dates[data_idx]).date()
open_pos = False
close_pos = False
if get_config().REBALANCE_FRI:
if date.isoweekday() == 5:
open_pos = True
if date.isoweekday() == 5:
close_pos = True
else:
if data_idx % get_config().REBALANCE_FREQ == 0:
close_pos = True
open_pos = True
if close_pos:
rpl = np.sum(pos * (curr_px - pos_px))
cash += rpl
pos[:] = 0
if open_pos:
pos_px = curr_px
pos_mask = port_mask[:, data_idx]
num_stks = np.sum(pos_mask)
if get_config().CAPM:
exp, cov = env.get_exp_and_cov(
pos_mask, global_data_idx -
get_config().COVARIANCE_LENGTH + 1,
global_data_idx)
exp = get_config().REBALANCE_FREQ * exp
cov = get_config().REBALANCE_FREQ * get_config(
).REBALANCE_FREQ * cov
if get_config().CAPM_USE_NET_PREDICTIONS:
exp = predictions[:, i, 0][pos_mask]
capm = Capm(num_stks)
capm.init()
best_sharpe = None
best_weights = None
best_constriant = None
while i <= 10000:
w, sharpe, constraint = capm.get_params(
exp, cov)
# print("Iteration: %d Sharpe: %.2f Constraint: %.6f" % (i, sharpe, constraint))
if w is None:
break
if best_sharpe is None or sharpe >= best_sharpe:
best_weights = w
best_sharpe = sharpe
best_constriant = constraint
capm.fit(exp, cov)
capm.rescale_weights()
i += 1
date = datetime.datetime.fromtimestamp(
raw_dates[data_idx]).date()
print(
"Date: %s sharpe: %.2f constraint: %.6f" %
(date.strftime('%Y-%m-%d'), best_sharpe,
best_constriant))
pos[pos_mask] = best_weights / curr_px[pos_mask]
else:
pos[pos_mask] = 1 / num_stks / curr_px[
pos_mask] * np.sign(predictions[pos_mask,
i, 0])
urpl = np.sum(pos * (curr_px - pos_px))
nlv = cash + urpl
eq[data_idx] = nlv
losses[b] = loss
curr_progress = progress.print_progress(
curr_progress, b, tr_batch_num)
progress.print_progess_end()
avg_loss = np.mean(np.sqrt(losses))
return avg_loss
