exponent = epoch - 50
else:
exponent = epoch + 1
LR = init_LR * pow(exponential_decay_rate, exponent)
print(
'Reducing learning rate-epoch = %d, current Learning rate= ' %
(epoch + 1), LR)
print('-' * 100)
# shuffle the training data at the begining of each epoch!
curr_train_dict = dataProcessing.shuffle_train_dict(
train_dict, markets)
# loop over all batches:
for batch_number in range(total_batches):
xBatch, trainY_batch = dataProcessing.next_batch_dict(
curr_train_dict, batch_number, batch_size, rem, Y_toUse,
total_batches, markets)
# run optimization
_ = sess.run(optimizer,
feed_dict={
x: xBatch,
y: trainY_batch,
learning_rate: LR,
def myMainFunc(random_start_indicies):
markets = ('SQ', 'MQ', 'NQ', 'DQ', 'RN')
# objective function
# objective = losses_and_metrics.sum_sharpeLoss
objective = losses_and_metrics.sharpeLoss
# objective = losses_and_metrics.basket_trading_pos_size_sharpeLoss
curr_optimizer = tf.train.AdamOptimizer
# curr_optimizer = tf.train.RMSPropOptimizer
# data parameters
Y_toUse = 1 # 1: scaled return, 2:1-day return
lookback = 30
lookahead = 1
rolling_sd_window = 100
# training parameters:
batch_size = 100
# network parameters:
network_activation = tf.nn.tanh
dropout = 1.
input_feats = lookback
test_start_date = 20070418
hidden_size_grid = [5, 10, 15, 20]
learning_rate_grid = [0.001, 0.0005, 0.0001, 0.00005]
epoch_grid = [50, 100, 150, 200, 300]
l2_grid = [0, 0.01, 0.1, 1, 5]
valid_frac = 0.2
# loading data
datadir = 'C:/behrouz/Projects/DailyModels_new/NeuralNet/hyper-param-optimization/tf-hyperParam-opt/data/%s_Commision-and-Slippage-limits.csv'
# get the common dates and then merge each data making sure they have common dates:
data = pd.read_csv(datadir % markets[0])
for i in range(1, len(markets), 1):
data1 = pd.read_csv(datadir % markets[i])
data = pd.merge(data, data1, on='dtStart', how='inner')
dates = data[['dtStart']]
# getting random piece but common indicies from train as validation
test_start_ind = int(np.where(dates.values == test_start_date)
[0]) - rolling_sd_window - lookback - lookahead
inds = np.arange(test_start_ind)
valid_inds = pd.read_csv('Validation_indicies.csv').values
valid_inds = valid_inds.flatten()
#valid_inds = np.random.choice(inds, size=int(valid_frac * test_start_ind), replace=False)
#valid_inds = np.sort(valid_inds)
# writing validation indicies to file
# valid_inds_df = pd.DataFrame(valid_inds)
#valid_inds_df.to_csv('Validation_indicies.csv', index=False)
train_inds = [i for i in inds if i not in valid_inds]
test_dict = {}
train_dict = {}
validation_dict = {}
for i in range(0, len(markets), 1):
data = pd.read_csv(datadir % markets[i])
# Make sure we get data from all markets on exact common dates
data = pd.merge(data, dates, on='dtStart', how='inner')
curr_market_data = \
dataProcessing.time_series_toMatrix(data, train_inds, valid_inds , 20070418, lookback = lookback,
look_ahead = lookahead, sd_window = rolling_sd_window)
train_dict[markets[i]] = copy.deepcopy(curr_market_data[:4])
validation_dict[markets[i]] = copy.deepcopy(curr_market_data[4:8])
test_dict[markets[i]] = copy.deepcopy(curr_market_data[8:])
total_batches = train_dict[markets[0]][0].shape[0] // batch_size
rem = train_dict[markets[0]][0].shape[0] % batch_size
print('TOTAL BATCHES+++++++++++++++++++++++', total_batches)
for R in random_start_indicies:
print('RUN %d optimization begins..' % R)
for hidden_size in hidden_size_grid:
for LR in learning_rate_grid:
for training_epochs in epoch_grid:
for l2Reg in l2_grid:
print('Hidden Size =', hidden_size, 'Learning rate=',
LR, 'TrainingEpochs=', training_epochs,
'L2 Reg=', l2Reg)
weights = {
'h1':
initializers.xavier_from_tf_initializer(
[lookback, hidden_size], name='W_1'),
'h2':
initializers.xavier_from_tf_initializer(
[hidden_size, hidden_size], name='W_2'),
'out':
initializers.xavier_from_tf_initializer(
[hidden_size, 1], name='W_out')
}
biases = {
'b1':
initializers.bias_initializer([hidden_size],
name='B_1'),
'b2':
initializers.bias_initializer([hidden_size],
name='B_2'),
'out':
initializers.bias_initializer([1], name='B_out')
}
# placeholders
x = tf.placeholder(tf.float32, [None, input_feats])
y = tf.placeholder(tf.float32, [None])
learning_rate = tf.placeholder(tf.float32)
keep_prob = tf.placeholder(tf.float32)
optimizer, output, sharpe_plus_l2_loss = \
MLP_1layer(x, y, weights, biases, keep_prob, curr_optimizer, learning_rate, objective,
batch_size=batch_size,
markets=markets,
activation=network_activation, l2Reg=l2Reg, l2RegOutput=l2Reg * 1.,
l2Reg_biases=l2Reg * 1.)
# initialize all tensors- to be run in Session!
init = tf.global_variables_initializer()
# saver for restoring the whole model graph of
# tensors from the checkpoint file
saver = tf.train.Saver()
# launch default graph:
with tf.Session() as sess:
sess.run(init)
# training cycle:
for epoch in range(training_epochs):
# shuffle the training data at the begining of each epoch!
curr_train_dict = dataProcessing.shuffle_train_dict(
train_dict, markets)
# loop over all batches:
for batch_number in range(total_batches):
xBatch, trainY_batch = dataProcessing.next_batch_dict(
curr_train_dict, batch_number,
batch_size, rem, Y_toUse,
total_batches, markets)
# run optimization
_ = sess.run(optimizer,
feed_dict={
x: xBatch,
y: trainY_batch,
learning_rate: LR,
keep_prob: dropout
})
#print(' Optimization finished! saving model graph of all tensors to file')
save_path = saver.save(
sess,
'./MLP-checkpointFiles/run%d-s-%d-LR-%.6f-epoch-%d-l2-%.5f.ckpt'
% (R, hidden_size, LR, training_epochs, l2Reg))
# resetting the graph to be built again in the next iteration of for loop
tf.reset_default_graph()
return random_start_indicies