def main():
params = get_params()
datasetD = make_seq_2_seq_dataset(params)
train_x = datasetD['train']['x']
train_y = datasetD['train']['y']
test_x = datasetD['test']['x']
test_y = datasetD['test']['y']
train_scenarios = datasetD['train']['scenarios']
test_scenarios = datasetD['test']['scenarios']
val_scenarios = datasetD['val']['scenarios']
params.scaleD = datasetD['scaleD']
input_window_samps = params.input_window_length_samples
num_signals = params.num_signals
output_window_samps = params.output_window_length_samples
train_X = np.array(train_x, dtype=float)
# train_X=np.reshape(train_X,(input_window_samps,-1))
#
train_Y = np.array(train_y, dtype=float)
nsamples, nx, ny = train_Y.shape
# print(nsamples)
# print(nx)
# print(ny)
train_Y = np.reshape(train_Y,
(nsamples, output_window_samps * num_signals))
print(train_X.shape)
#print(len(train_X[0,:]))
print(train_Y.shape)
print(train_Y)
# print(input_window_samps)
# print(num_signals)
# print(output_window_samps)
# train_x = Reshape((input_window_samps,num_signals))(train_x)
# print(train_x.shape)
# print(train_x[0,:])
#
# train_y = Reshape((output_window_samps, num_signals))(train_y)
# print(train_y.shape)
# print(train_y[0,:])
model = SVR(kernel='rbf', degree=3)
history = model.fit(train_X, train_Y)
history_score = history.score(test_x, test_y)
print("the score of linear is : %f" % history_score)
def main():
# tf.compat.v1.enable_v2_behavior()
print("tensorflow version =", tf.__version__)
# get and save params of this run
params = get_params()
# dataset = Seq2SeqDataset_copy(
# input_path=params.input_dir,
# input_window_length_samples =params.input_window_length_samples,
# output_window_length_samples=params.output_window_length_samples,
# )
# train_dataset = tf.data.Dataset.from_generator((train_x, train_y),output_types=(tf.float64,tf.float64))
# train_dataset = train_dataset.shuffle(buffer_size=100000)
# train_dataset = train_dataset.repeat()
datasetD = make_seq_2_seq_dataset(params)
train_x = datasetD['train']['x']
train_y = datasetD['train']['y']
test_x = datasetD['test']['x']
test_y = datasetD['test']['y']
val_x = datasetD['val']['x']
val_y = datasetD['val']['y']
train_scenarios = datasetD['train']['scenarios']
test_scenarios = datasetD['test']['scenarios']
val_scenarios = datasetD['val']['scenarios']
params.scaleD = datasetD['scaleD'] # store scaleD in params_out.yml
#model = create_model(params)
#model.compile(optimizer=params.optimizer,
# loss=params.loss,
# metrics=get_metrics(params))
input_window_samps = params.input_window_length_samples
num_signals = params.num_signals
output_window_samps = params.output_window_length_samples
train_x = tf.reshape(train_x, [input_window_samps, num_signals])
train_y = tf.reshape(train_y, [output_window_samps, num_signals])
test_x = tf.reshape(test_x, [input_window_samps, num_signals])
test_y = tf.reshape(test_y, [output_window_samps, num_signals])
model = SVR(kernel='rbf', degree=3)
history = model.fit([train_x], [train_y])
history_score = history.score(test_x, test_y)
print("the score of linear is : %f" % history_score)
def main():
start = time.clock()
params = get_params()
datasetD = make_seq_2_seq_dataset(params)
train_x = datasetD['train']['x']
train_y = datasetD['train']['y']
test_x = datasetD['test']['x']
test_y = datasetD['test']['y']
input_window_samps = params.input_window_length_samples
num_signals = params.num_signals
output_window_samps = params.output_window_length_samples
train_X = np.array(train_x, dtype=float)
train_Y = np.array(train_y, dtype=float)
nsamples, nx = train_X.shape
print(nsamples)
print(nx)
train_Y = np.reshape(train_Y,
(nsamples, output_window_samps * num_signals))
test_X = np.array(test_x, dtype=float)
print(test_X.shape)
test_Y = np.array(test_y, dtype=float)
test_sample, test_nx = test_X.shape
test_Y = np.reshape(test_Y,
(test_sample, output_window_samps * num_signals))
print(test_Y.shape)
train_Y_SVR = train_Y[:, 8:]
test_Y_SVR = test_Y[:, 8:]
model_SVR = MultiOutputRegressor(SVR(kernel='rbf', degree=3))
model_SVR.fit(train_X, train_Y_SVR)
result_SVR = model_SVR.predict(test_X)
score_SVR = metrics.mean_squared_error(test_Y_SVR, result_SVR)
f = open(
'C:/Users/HD1047208/OneDrive - Bose Corporation/Desktop/data/Hang_SVR.pickle',
'wb')
pickle.dump(model_SVR, f)
f.close()
print(score_SVR)
plt.figure()
plt.plot(np.arange(len(result_SVR)),
result_SVR[:, 0],
'r-',
label='predict value_x0')
plt.plot(np.arange(len(result_SVR)),
result_SVR[:, 1],
'b-',
label='predict value_y0')
plt.plot(np.arange(len(result_SVR)),
result_SVR[:, 2],
'g-',
label='predict value_z0')
plt.plot(np.arange(len(result_SVR)),
result_SVR[:, 3],
'y-',
label='predict value_w0')
plt.plot(np.arange(len(result_SVR)),
test_Y_SVR[:, 0],
'k-',
label='test value_x0')
plt.plot(np.arange(len(result_SVR)),
test_Y_SVR[:, 1],
'm-',
label='test value_y0')
plt.plot(np.arange(len(result_SVR)),
test_Y_SVR[:, 2],
'c-',
label='test value_z0')
plt.plot(np.arange(len(result_SVR)),
test_Y_SVR[:, 3],
'k-',
label='test value_w0')
plt.xlabel('length')
plt.ylabel('result')
plt.title('SVR prediction')
plt.legend()
plt.show()
print(result_SVR.shape)
print(test_Y.shape)
print(time.clock() - start)
def main():
# tf.compat.v1.enable_v2_behavior()
print("tensorflow version =", tf.__version__)
# get and save params of this run
params = get_params()
# dataset = Seq2SeqDataset_copy(
# input_path=params.input_dir,
# input_window_length_samples =params.input_window_length_samples,
# output_window_length_samples=params.output_window_length_samples,
# )
# train_dataset = tf.data.Dataset.from_generator((train_x, train_y),output_types=(tf.float64,tf.float64))
# train_dataset = train_dataset.shuffle(buffer_size=100000)
# train_dataset = train_dataset.repeat()
datasetD = make_seq_2_seq_dataset(params)
train_x = datasetD['train']['x']
train_y = datasetD['train']['y']
test_x = datasetD['test']['x']
test_y = datasetD['test']['y']
val_x = datasetD['val']['x']
val_y = datasetD['val']['y']
train_scenarios = datasetD['train']['scenarios']
test_scenarios = datasetD['test']['scenarios']
val_scenarios = datasetD['val']['scenarios']
params.scaleD = datasetD['scaleD'] # store scaleD in params_out.yml
model = create_model(params)
model.compile(optimizer=params.optimizer,
loss=params.loss,
metrics=get_metrics(params))
print(model.summary())
history = model.fit([train_x], [train_y],
batch_size=32,
epochs=params.num_epochs,
callbacks=make_callbacks(params),
validation_data=([val_x], [val_y]),
validation_freq=1)
# history = model.fit(dataset.train_dataset,
# epochs=params.num_epochs,
# steps_per_epoch=int(dataset.num_train),
# # callbacks=make_callbacks(params),
# validation_data=dataset.val_dataset,
# validation_steps=int(dataset.num_val),
# validation_freq=1)
with open(os.path.join(params.output_dir, 'history.pickle'), 'wb') as f:
pickle.dump(history.history, f)
# score = model.evaluate(dataset.test_dataset)
score = model.evaluate([test_x], [test_y])
score = [float(s)
for s in score] # convert values in score from np.float to float
params.score = score # store score in params_out.yml
if 'best_checkpoint' in params.callback_list: # load weights from best checkpoint
model.load_weights(
os.path.join(params.output_dir, "best-checkpoint-weights.h5"))
elif 'checkpoint' in params.callback_list:
pass
save_model(params, model)
with open(os.path.join(params.output_dir, 'params_out.yml'), 'w') as f:
yaml.dump(vars(params), f, default_flow_style=False)
plot_metrics(params)
plot_predictions(params, model, test_scenarios)
def main():
start = time.clock()
params = get_params()
datasetD = make_seq_2_seq_dataset(params)
train_x = datasetD['train']['x']
train_y = datasetD['train']['y']
test_x = datasetD['test']['x']
test_y = datasetD['test']['y']
input_window_samps = params.input_window_length_samples
num_signals = params.num_signals
output_window_samps = params.output_window_length_samples
train_X = np.array(train_x, dtype=float)
train_Y = np.array(train_y, dtype=float)
nsamples, nx = train_X.shape
print(nsamples)
print(nx)
train_Y = np.reshape(train_Y,
(nsamples, output_window_samps * num_signals))
test_X = np.array(test_x, dtype=float)
print(test_X.shape)
test_Y = np.array(test_y, dtype=float)
test_sample, test_nx = test_X.shape
test_Y = np.reshape(test_Y,
(test_sample, output_window_samps * num_signals))
print(test_Y.shape)
model_decision = DecisionTreeRegressor(random_state=0)
model_decision.fit(train_X, train_Y)
f = open(
'C:/Users/HD1047208/OneDrive - Bose Corporation/Desktop/data/Hang_decisionTree.pickle',
'wb')
pickle.dump(model_decision, f)
f.close()
result_decision = model_decision.predict(test_X)
score_decision = metrics.mean_squared_error(test_Y, result_decision)
print(result_decision.shape)
print(score_decision)
plt.figure(1)
plt.plot(np.arange(len(result_decision)),
result_decision[:, 8],
'r-',
label='predict value_x0')
plt.plot(np.arange(len(result_decision)),
result_decision[:, 9],
'b-',
label='predict value_y0')
plt.plot(np.arange(len(result_decision)),
result_decision[:, 10],
'g-',
label='predict value_z0')
plt.plot(np.arange(len(result_decision)),
result_decision[:, 11],
'y-',
label='predict value_w0')
plt.plot(np.arange(len(result_decision)),
test_Y[:, 8],
'k-',
label='test value_x0')
plt.plot(np.arange(len(result_decision)),
test_Y[:, 9],
'm-',
label='test value_y0')
plt.plot(np.arange(len(result_decision)),
test_Y[:, 10],
'c-',
label='test value_z0')
plt.plot(np.arange(len(result_decision)),
test_Y[:, 11],
'k-',
label='test value_w0')
plt.xlabel('length')
plt.ylabel('result')
plt.title('decision_tree prediction')
plt.legend()
plt.show()
print(time.clock() - start)