def regression2Cls_score(self):
c = self.config
#c['checkpoint_dir'] = './model/test_onlyEnc_biderect_gru_orth_init'
tv_gen = dp.train_validation_generaotr()
_, evalSet, *_ = tv_gen.generate_train_val_set_mStock(
c['src_file_path'],
c['input_stocks'],
c['input_step'],
c['predict_step'],
c['train_eval_ratio'],
metafile=c['meta_file_path'])
if c['feature_size'] == None: c['feature_size'] = evalSet.shape[-1]
c['batch_size'] = len(evalSet)
train, label = np.split(evalSet, [c['input_step']], axis=1)
train = np.reshape(train[:, :, :c['feature_size']],
(c['batch_size'], c['input_step'], -1))
label_reg = label[:, :, 3]
tf.reset_default_graph()
x = tf.placeholder(tf.float32,
[None, c['input_step'], c['feature_size']])
y = tf.placeholder(tf.float32, [None, c['predict_step']])
predict_reg = mz.model_zoo(c, x, y, dropout=1.0,
is_train=False).decoder_output
predict_reg_resore = predict_reg * self.std + self.mean
label_reg_restore = y * self.std + self.mean
with tf.Session() as sess:
saver = tf.train.Saver()
if ut.load_ckpt(saver, sess, c['checkpoint_dir'], c['ckpt_name']):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
predict_s, label_reg_s = sess.run(
[predict_reg_resore, label_reg_restore],
feed_dict={
x: train,
y: label_reg
})
label_cls = np.argmax(label[:, :, -3:], axis=-1)
last_price = np.reshape(label_reg_s[:, -1], (-1, 1))
concat_price = np.concatenate((last_price, predict_s), axis=1)
_, cls_res = self.generate_cls_from_reg(concat_price)
sess.close()
match_matrix = np.equal(cls_res, label_cls)
match_matrix = match_matrix * 0.5 * self.weighted_array
score = np.mean(np.sum(match_matrix, axis=1))
return score, match_matrix, cls_res, label_cls, label_reg
def classification_score(self):
tf.reset_default_graph()
c = self.config
tv_gen = dp.train_validation_generaotr()
_, evalSet, *_ = tv_gen.generate_train_val_set_mStock(
c['src_file_path'],
c['input_stocks'],
c['input_step'],
c['predict_step'],
c['train_eval_ratio'],
metafile=c['meta_file_path'])
if c['feature_size'] == None: c['feature_size'] = evalSet.shape[-1]
c['batch_size'] = len(evalSet)
train, label = np.split(evalSet, [c['input_step']], axis=1)
train = np.reshape(train[:, :, :c['feature_size']],
(c['batch_size'], c['input_step'], -1))
label_cls = label[:, :, -3:]
x = tf.placeholder(tf.float32,
[None, c['input_step'], c['feature_size']])
y = tf.placeholder(tf.float32, [None, c['predict_step'], 3])
logits = mz.model_zoo(c, x, y, dropout=1.0,
is_train=False).decoder_output
softmax_out = tf.nn.softmax(logits)
predict_cls = tf.argmax(tf.nn.softmax(logits), axis=-1)
ground_truth = tf.argmax(y, axis=-1)
plane_result = tf.cast(tf.equal(predict_cls, ground_truth), tf.float32)
weighted_result = plane_result * 0.5 * self.weighted_array
score_tf = tf.reduce_sum(weighted_result, axis=1)
mean_score = tf.reduce_mean(score_tf)
with tf.Session() as sess:
saver = tf.train.Saver()
if ut.load_ckpt(saver, sess, c['checkpoint_dir'], c['ckpt_name']):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
loss_s, softmax_out_s, predict_s, gt = sess.run(
[logits, softmax_out, predict_cls, ground_truth],
feed_dict={
x: train,
y: label_cls
})
result_cls, score, w_score, mean_score_cls = sess.run(
[plane_result, score_tf, weighted_result, mean_score],
feed_dict={
x: train,
y: label_cls
})
return mean_score_cls, softmax_out_s, gt
def regression_score(self):
c = self.config
tv_gen = dp.train_validation_generaotr()
_, evalSet, *_ = tv_gen.generate_train_val_set_mStock(
c['src_file_path'],
c['input_stocks'],
c['input_step'],
c['predict_step'],
c['train_eval_ratio'],
metafile=c['meta_file_path'])
if c['feature_size'] == None: c['feature_size'] = evalSet.shape[-1]
c['batch_size'] = len(evalSet)
train, label = np.split(evalSet, [c['input_step']], axis=1)
train = np.reshape(train[:, :, :c['feature_size']],
(c['batch_size'], c['input_step'], -1))
label_reg = label[:, :, 3]
tf.reset_default_graph()
x = tf.placeholder(tf.float32,
[None, c['input_step'], c['feature_size']])
y = tf.placeholder(tf.float32, [None, c['predict_step']])
predict_reg = mz.model_zoo(c, x, y, dropout=1.0,
is_train=False).decoder_output
predict_reg_resore = predict_reg * self.std + self.mean
label_reg_restore = label_reg * self.std + self.mean
abs_loss = tf.abs(predict_reg_resore - label_reg_restore)
score_ref = ((label_reg_restore - abs_loss) / label_reg_restore) * 0.5
w_score = self.weighted_array * score_ref
mean_score = tf.reduce_mean(tf.reduce_sum(w_score, axis=1))
with tf.Session() as sess:
saver = tf.train.Saver()
if ut.load_ckpt(saver, sess, c['checkpoint_dir'], c['ckpt_name']):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
predict = sess.run(predict_reg, feed_dict={x: train, y: label_reg})
loss, plain_scores, w_scores, mean_score_reg = sess.run(
[abs_loss, score_ref, w_score, mean_score],
feed_dict={
x: train,
y: label_reg
})
sess.close()
return mean_score_reg, predict, label_reg
mask = np.zeros(np.shape(data)[-1], dtype=bool)
for i in range(len(mask)):
if i in feature_mask:
mask[i] = True
else:
mask[i] = False
return data[:, mask]
tf.reset_default_graph()
c = conf.config('trial_cnn_cls').config['common']
sample_window = c['input_step'] + c['predict_step']
tv_gen = dp.train_validation_generaotr()
f = tv_gen._load_data(c['src_file_path'])
stock = tv_gen._selectData2array(f, ['0050'], None)
train = stock[:769]
validation = stock[769:]
train_data = train
train_label = train[:, -3:]
validation_data = validation
validation_label = validation[:, -3:]
#Train shift 1 day
lag_day = 5
train_data = train_data[:-lag_day]
def get_ens_model(lagday=5,
model_temp=xgb.XGBClassifier(max_depth=3,
learning_rate=0.05,
n_estimators=500,
silent=True)):
print('**********Generate model for {} day***********'.format(lagday))
c = conf.config('trial_cnn_cls').config['common']
*_, meta = gu.read_metafile(c['meta_file_path'])
tv_gen = dp.train_validation_generaotr()
f = tv_gen._load_data(c['src_file_path'])
data = tv_gen._selectData2array(f, f.index[:-4], None)
data_velocity = (data[1:, 0:4] - data[:-1, 0:4]) / (data[:-1, 0:4] + 0.1)
data = data[1:]
train_sample = data[:-30]
train_sample_v = data_velocity[:-30]
flat_train_sample = np.reshape(np.transpose(train_sample, (0, 2, 1)),
(-1, 94))
flat_train_sample_velocity = np.reshape(
np.transpose(train_sample_v, (0, 2, 1)), (-1, 4))
test_sample = data[-30:]
test_sample_v = data_velocity[-30:]
flat_test_sample = np.reshape(np.transpose(test_sample, (0, 2, 1)),
(-1, 94))
flat_test_sample_velocity = np.reshape(
np.transpose(test_sample_v, (0, 2, 1)), (-1, 4))
#
# flat_train_sample = train_data['train']
# flat_train_sample_velocity = train_data['train_velocity']
#
# flat_test_sample = test_data['test']
# flat_test_sample_velocity = test_data['test_velocity']
fe_train = feature_extractor(flat_train_sample, flat_train_sample_velocity)
d_ratio = fe_train.ratio()
d_kdj_ratio = fe_train.kdj_ratio()
d_ratio_velocity = fe_train.ratio_velocity()
d_ud = fe_train.ud()
d_kdj_macd_rssi_ratio = fe_train.kdj_macd_rssi_ratio()
fe_test = feature_extractor(flat_test_sample, flat_test_sample_velocity)
d_ratio_test = fe_test.ratio()
d_kdj_ratio_test = fe_test.kdj_ratio()
d_ratio_velocity_test = fe_test.ratio_velocity()
d_ud_test = fe_test.ud()
d_kdj_macd_rssi_ratio_test = fe_test.kdj_macd_rssi_ratio()
train_label_raw = np.stack(
(flat_train_sample[:, -3] + flat_train_sample[:, -2],
flat_train_sample[:, -1]),
axis=1)
test_label_raw = np.stack(
(flat_test_sample[:, -3] + flat_test_sample[:, -2],
flat_test_sample[:, -1]),
axis=1)
model_dict = {}
predict_dict = {}
#*****ratio********
train, train_label = data_label_shift(d_ratio,
train_label_raw,
lag_day=lagday)
test, test_label = data_label_shift(d_ratio_test,
test_label_raw,
lag_day=lagday)
train_label = np.argmax(train_label, axis=-1)
test_label = np.argmax(test_label, axis=-1)
model = xgb.XGBClassifier(max_depth=3,
learning_rate=0.05,
n_estimators=500,
silent=True)
model.fit(train, train_label)
model_dict['ratio'] = model
y_xgb_train = model.predict(train)
y_xgb_v = model.predict(test)
predict_dict['ratio'] = [y_xgb_train, y_xgb_v]
print("Train Accuracy [ratio]: ", accuracy_score(y_xgb_train, train_label))
print("Validation Accuracy [ratio]: ", accuracy_score(y_xgb_v, test_label))
#*****kdj_ratio********
train = d_kdj_ratio[:-lagday]
test = d_kdj_ratio_test[:-lagday]
model = xgb.XGBClassifier(max_depth=3,
learning_rate=0.05,
n_estimators=500,
silent=True)
model.fit(train, train_label)
model_dict['kdj_ratio'] = model
y_xgb_train = model.predict(train)
y_xgb_v = model.predict(test)
predict_dict['kdj_ratio'] = [y_xgb_train, y_xgb_v]
print("Train Accuracy [kdj_ratio]: ",
accuracy_score(y_xgb_train, train_label))
print("Validation Accuracy [kdj_ratio]: ",
accuracy_score(y_xgb_v, test_label))
#*****ratio_velocity********
train = d_ratio_velocity[:-lagday]
test = d_ratio_velocity_test[:-lagday]
model = xgb.XGBClassifier(max_depth=3,
learning_rate=0.05,
n_estimators=500,
silent=True)
model.fit(train, train_label)
model_dict['ratio_velocity'] = model
y_xgb_train = model.predict(train)
y_xgb_v = model.predict(test)
predict_dict['ratio_velocity'] = [y_xgb_train, y_xgb_v]
print("Train Accuracy [ratio_velocity]: ",
accuracy_score(y_xgb_train, train_label))
print("Validation Accuracy [ratio_velocity]: ",
accuracy_score(y_xgb_v, test_label))
#*****ud********
train = d_ud[:-lagday]
test = d_ud_test[:-lagday]
model = xgb.XGBClassifier(max_depth=3,
learning_rate=0.05,
n_estimators=500,
silent=True)
model.fit(train, train_label)
model_dict['ud'] = model
y_xgb_train = model.predict(train)
y_xgb_v = model.predict(test)
predict_dict['ud'] = [y_xgb_train, y_xgb_v]
print("Train Accuracy [ud]: ", accuracy_score(y_xgb_train, train_label))
print("Validation Accuracy [ud]: ", accuracy_score(y_xgb_v, test_label))
#*****kdj_macd_rssi_ratio********
train = d_kdj_macd_rssi_ratio[:-lagday]
test = d_kdj_macd_rssi_ratio_test[:-lagday]
model = xgb.XGBClassifier(max_depth=3,
learning_rate=0.05,
n_estimators=500,
silent=True)
model.fit(train, train_label)
model_dict['kdj_macd_rssi_ratio'] = model
y_xgb_train = model.predict(train)
y_xgb_v = model.predict(test)
predict_dict['kdj_macd_rssi_ratio'] = [y_xgb_train, y_xgb_v]
print("Train Accuracy [kdj_macd_rssi_ratio]: ",
accuracy_score(y_xgb_train, train_label))
print("Validation Accuracy [kdj_macd_rssi_ratio]: ",
accuracy_score(y_xgb_v, test_label))
#*********Generate assemble input***********
predict_train = []
predict_test = []
for k in predict_dict:
predict_train.append(predict_dict[k][0])
predict_test.append(predict_dict[k][1])
predict_train = np.stack(predict_train, axis=1)
predict_test = np.stack(predict_test, axis=1)
model = xgb.XGBClassifier(max_depth=3,
learning_rate=0.05,
n_estimators=10,
silent=True)
model.fit(predict_train, train_label)
model_dict['ensemble'] = model
y_xgb_train_ens = model.predict(predict_train)
y_xgb_v_ens = model.predict(predict_test)
print("Train Accuracy [Ens]: ", accuracy_score(y_xgb_train_ens,
train_label))
print("Validation Accuracy [Ens]: ",
accuracy_score(y_xgb_v_ens, test_label))
return model_dict
