Skip to content

Commit 23a8edc

Browse files
thieu1995thieu1995
committed
Update root files
1 parent 35173e3 commit 23a8edc

File tree

5 files changed

+149
-132
lines changed

5 files changed

+149
-132
lines changed

‎model/root/hybrid/root_hybrid_mlnn.py‎

Lines changed: 48 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -1,93 +1,78 @@
1-
import numpy as np
2-
import time
1+
#!/usr/bin/env python
2+
# ------------------------------------------------------------------------------------------------------%
3+
# Created by "Thieu Nguyen" at 18:22, 06/04/2020 %
4+
# %
5+
# Email: [email protected] %
6+
# Homepage: https://www.researchgate.net/profile/Thieu_Nguyen6 %
7+
# Github: https://github.com/thieunguyen5991 %
8+
# -------------------------------------------------------------------------------------------------------%
9+
10+
from sklearn.metrics import mean_squared_error
11+
from numpy import reshape, add, matmul
12+
from time import time
313
from model.root.root_base import RootBase
4-
from utils.MathUtil import elu, relu, tanh, sigmoid
5-
from sklearn.metrics import mean_absolute_error, mean_squared_error
14+
import utils.MathUtil as my_math
15+
616

7-
class RootHybridMlnn(RootBase):
17+
class RootHybridMlp(RootBase):
818
"""
9-
This is root of all hybrid models which include Multi-layer Neural Network and Optimization Algorithms.
19+
This is root of all hybrid multi-layer neural network (meta-heuristics + MLNN)
1020
"""
21+
1122
def __init__(self, root_base_paras=None, root_hybrid_paras=None):
1223
RootBase.__init__(self, root_base_paras)
13-
self.epoch = root_hybrid_paras["epoch"]
14-
self.activations = root_hybrid_paras["activations"]
15-
self.hidden_size = root_hybrid_paras["hidden_size"]
16-
self.train_valid_rate = root_hybrid_paras["train_valid_rate"]
1724
self.domain_range = root_hybrid_paras["domain_range"]
18-
19-
if self.activations[0] == 0:
20-
self._activation1__ = elu
21-
elif self.activations[0] == 1:
22-
self._activation1__ = relu
23-
elif self.activations[0] == 2:
24-
self._activation1__ = tanh
25-
else:
26-
self._activation1__ = sigmoid
27-
28-
if self.activations[1] == 0:
29-
self._activation2__ = elu
30-
elif self.activations[1] == 1:
31-
self._activation2__ = relu
32-
elif self.activations[1] == 2:
33-
self._activation2__ = tanh
25+
self.activations = root_hybrid_paras["activations"]
26+
if root_hybrid_paras["hidden_size"][1]:
27+
self.hidden_size = root_hybrid_paras["hidden_size"][0]
3428
else:
35-
self._activation2__ = sigmoid
29+
self.hidden_size = 2 * root_base_paras["sliding"] * root_base_paras["feature_size"] + 1
30+
self.problem_size, self.epoch = None, None
3631

3732
def _setting__(self):
33+
## New discovery
34+
self._activation1__ = getattr(my_math, self.activations[0])
35+
self._activation2__ = getattr(my_math, self.activations[1])
36+
3837
self.input_size, self.output_size = self.X_train.shape[1], self.y_train.shape[1]
3938
self.w1_size = self.input_size * self.hidden_size
4039
self.b1_size = self.hidden_size
4140
self.w2_size = self.hidden_size * self.output_size
4241
self.b2_size = self.output_size
4342
self.problem_size = self.w1_size + self.b1_size + self.w2_size + self.b2_size
44-
self.root_algo_paras = {
45-
"X_train": self.X_train, "y_train": self.y_train, "X_valid": self.X_valid, "y_valid": self.y_valid,
46-
"train_valid_rate": self.train_valid_rate, "domain_range": self.domain_range,
47-
"problem_size": self.problem_size, "print_train": self.print_train,
48-
"_get_average_error__": self._get_average_error__
49-
}
5043

5144
def _forecasting__(self):
52-
hidd = self._activation1__(np.add(np.matmul(self.X_test, self.model["w1"]), self.model["b1"]))
53-
y_pred = self._activation2__(np.add(np.matmul(hidd, self.model["w2"]), self.model["b2"]))
45+
hidd = self._activation1__(add(matmul(self.X_test, self.model["w1"]), self.model["b1"]))
46+
y_pred = self._activation2__(add(matmul(hidd, self.model["w2"]), self.model["b2"]))
5447
real_inverse = self.scaler.inverse_transform(self.y_test)
55-
pred_inverse = self.scaler.inverse_transform(np.reshape(y_pred, self.y_test.shape))
48+
pred_inverse = self.scaler.inverse_transform(reshape(y_pred, self.y_test.shape))
5649
return real_inverse, pred_inverse, self.y_test, y_pred
5750

5851
def _running__(self):
59-
self.time_system = time.time()
52+
self.time_system = time()
6053
self._preprocessing_2d__()
6154
self._setting__()
62-
self.time_total_train = time.time()
55+
self.time_total_train = time()
6356
self._training__()
64-
self._get_model__(self.solution)
65-
self.time_total_train = round(time.time() - self.time_total_train, 4)
57+
self.model = self._get_model__(self.solution)
58+
self.time_total_train = round(time() - self.time_total_train, 4)
6659
self.time_epoch = round(self.time_total_train / self.epoch, 4)
67-
self.time_predict = time.time()
68-
y_actual, y_predict, y_actual_normalized, y_predict_normalized = self._forecasting__()
69-
self.time_predict = round(time.time() - self.time_predict, 6)
70-
self.time_system = round(time.time() - self.time_system, 4)
71-
if self.test_type == "normal":
72-
self._save_results__(y_actual, y_predict, y_actual_normalized, y_predict_normalized, self.loss_train)
73-
elif self.test_type == "stability":
74-
self._save_results_ntimes_run__(y_actual, y_predict, y_actual_normalized, y_predict_normalized)
60+
self.time_predict = time()
61+
y_true_unscaled, y_pred_unscaled, y_true_scaled, y_pred_scaled = self._forecasting__()
62+
self.time_predict = round(time() - self.time_predict, 8)
63+
self.time_system = round(time() - self.time_system, 4)
64+
self._save_results__(y_true_unscaled, y_pred_unscaled, y_true_scaled, y_pred_scaled, self.loss_train, self.n_runs)
7565

7666
## Helper functions
7767
def _get_model__(self, individual=None):
78-
w1 = np.reshape(individual[:self.w1_size], (self.input_size, self.hidden_size))
79-
b1 = np.reshape(individual[self.w1_size:self.w1_size + self.b1_size], (-1, self.hidden_size))
80-
w2 = np.reshape(individual[self.w1_size + self.b1_size: self.w1_size + self.b1_size + self.w2_size],
81-
(self.hidden_size, self.output_size))
82-
b2 = np.reshape(individual[self.w1_size + self.b1_size + self.w2_size:], (-1, self.output_size))
83-
self.model = {"w1": w1, "b1": b1, "w2": w2, "b2": b2}
68+
w1 = reshape(individual[:self.w1_size], (self.input_size, self.hidden_size))
69+
b1 = reshape(individual[self.w1_size:self.w1_size + self.b1_size], (-1, self.hidden_size))
70+
w2 = reshape(individual[self.w1_size + self.b1_size: self.w1_size + self.b1_size + self.w2_size], (self.hidden_size, self.output_size))
71+
b2 = reshape(individual[self.w1_size + self.b1_size + self.w2_size:], (-1, self.output_size))
72+
return {"w1": w1, "b1": b1, "w2": w2, "b2": b2}
8473

85-
def _get_average_error__(self, individual=None, X_data=None, y_data=None):
86-
w1 = np.reshape(individual[:self.w1_size], (self.input_size, self.hidden_size))
87-
b1 = np.reshape(individual[self.w1_size:self.w1_size + self.b1_size], (-1, self.hidden_size))
88-
w2 = np.reshape(individual[self.w1_size + self.b1_size: self.w1_size + self.b1_size + self.w2_size],
89-
(self.hidden_size, self.output_size))
90-
b2 = np.reshape(individual[self.w1_size + self.b1_size + self.w2_size:], (-1, self.output_size))
91-
hidd = self._activation1__(np.add(np.matmul(X_data, w1), b1))
92-
y_pred = self._activation2__(np.add(np.matmul(hidd, w2), b2))
93-
return [mean_squared_error(y_pred, y_data), mean_absolute_error(y_pred, y_data)]
74+
def _objective_function__(self, solution=None):
75+
md = self._get_model__(solution)
76+
hidd = self._activation1__(add(matmul(self.X_train, md["w1"]), md["b1"]))
77+
y_pred = self._activation2__(add(matmul(hidd, md["w2"]), md["b2"]))
78+
return mean_squared_error(y_pred, self.y_train)

‎model/root/root_base.py‎

Lines changed: 65 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,24 @@
1+
#!/usr/bin/env python
2+
# ------------------------------------------------------------------------------------------------------%
3+
# Created by "Thieu Nguyen" at 18:10, 06/04/2020 %
4+
# %
5+
# Email: [email protected] %
6+
# Homepage: https://www.researchgate.net/profile/Thieu_Nguyen6 %
7+
# Github: https://github.com/thieunguyen5991 %
8+
# -------------------------------------------------------------------------------------------------------%
9+
110
from sklearn.preprocessing import MinMaxScaler
211
from utils.PreprocessingUtil import TimeSeries
312
from utils.MeasureUtil import MeasureTimeSeries
413
from utils.IOUtil import save_all_models_to_csv, save_prediction_to_csv, save_loss_train_to_csv
514
from utils.GraphUtil import draw_predict_with_error
615

7-
class RootBase(object):
16+
17+
class RootBase:
818
"""
919
This is root of all networks.
1020
"""
21+
1122
def __init__(self, root_base_paras=None):
1223
self.dataset = root_base_paras["dataset"]
1324
self.data_idx = root_base_paras["data_idx"]
@@ -16,10 +27,10 @@ def __init__(self, root_base_paras=None):
1627
self.method_statistic = root_base_paras["method_statistic"]
1728
self.scaler = MinMaxScaler()
1829

30+
self.n_runs = root_base_paras["n_runs"]
1931
self.path_save_result = root_base_paras["path_save_result"]
2032
self.log_filename = root_base_paras["log_filename"]
2133
self.multi_output = root_base_paras["multi_output"]
22-
self.test_type = root_base_paras["test_type"]
2334
self.draw = root_base_paras["draw"]
2435
self.print_train = root_base_paras["print_train"]
2536

@@ -35,57 +46,62 @@ def _preprocessing_3d__(self):
3546
ts = TimeSeries(self.dataset, self.data_idx, self.sliding, self.output_idx, self.method_statistic, self.scaler)
3647
self.X_train, self.y_train, self.X_valid, self.y_valid, self.X_test, self.y_test, self.scaler = ts._preprocessing_3d__()
3748

38-
def _save_results__(self, y_actual=None, y_predict=None, y_actual_normalized=None, y_predict_normalized=None, loss_train=None):
49+
def _save_results__(self, y_true=None, y_pred=None, y_true_scaled=None, y_pred_scaled=None, loss_train=None, n_runs=1):
3950
if self.multi_output:
40-
measure = MeasureTimeSeries(y_actual_normalized, y_predict_normalized, "raw_values", number_rounding=4)
41-
measure.fit()
42-
item = [self.filename, self.time_total_train, self.time_epoch, self.time_predict, self.time_system,
43-
measure.score_ev[0], measure.score_mae[0], measure.score_mse[0], measure.score_msle[0],
44-
measure.score_r2[0], measure.score_rmse[0], measure.score_mape[0], measure.score_smape[0],
45-
measure.score_ev[1], measure.score_mae[1], measure.score_mse[1], measure.score_msle[1],
46-
measure.score_r2[1], measure.score_rmse[1], measure.score_mape[1], measure.score_smape[1],
47-
]
51+
measure_scaled = MeasureTimeSeries(y_true_scaled, y_pred_scaled, "raw_values", number_rounding=4)
52+
measure_scaled._fit__()
53+
data1 = "CPU_"
54+
data2 = "RAM_"
55+
item = {'model_name': self.filename, 'total_time_train': self.time_total_train, 'time_epoch': self.time_epoch,
56+
'time_predict': self.time_predict, 'time_system': self.time_system,
57+
data1 + 'scaled_EV': measure_scaled.score_ev[0], data1 + 'scaled_MSLE': measure_scaled.score_msle[0],
58+
data1 + 'scaled_R2': measure_scaled.score_r2[0], data1 + 'scaled_MAE': measure_scaled.score_mae[0],
59+
data1 + 'scaled_MSE': measure_scaled.score_mse[0], data1 + 'scaled_RMSE': measure_scaled.score_rmse[0],
60+
data1 + 'scaled_MAPE': measure_scaled.score_mape[0], data1 + 'scaled_SMAPE': measure_scaled.score_smape[0],
61+
62+
data2 + 'scaled_EV': measure_scaled.score_ev[1], data2 + 'scaled_MSLE': measure_scaled.score_msle[1],
63+
data2 + 'scaled_R2': measure_scaled.score_r2[1], data2 + 'scaled_MAE': measure_scaled.score_mae[1],
64+
data2 + 'scaled_MSE': measure_scaled.score_mse[1], data2 + 'scaled_RMSE': measure_scaled.score_rmse[1],
65+
data2 + 'scaled_MAPE': measure_scaled.score_mape[1], data2 + 'scaled_SMAPE': measure_scaled.score_smape[1]}
66+
67+
if n_runs == 1:
68+
save_prediction_to_csv(y_true[:, 0:1], y_pred[:, 0:1], self.filename, self.path_save_result + data1)
69+
save_prediction_to_csv(y_true[:, 1:2], y_pred[:, 1:2], self.filename, self.path_save_result + data2)
70+
save_loss_train_to_csv(loss_train, self.filename, self.path_save_result + "Error-")
71+
72+
if self.draw:
73+
draw_predict_with_error(1, [y_true[:, 0:1], y_pred[:, 0:1]], [measure_scaled.score_rmse[0], measure_scaled.score_mae[0]], self.filename,
74+
self.path_save_result + data1)
75+
draw_predict_with_error(2, [y_true[:, 1:2], y_pred[:, 1:2]], [measure_scaled.score_rmse[1], measure_scaled.score_mae[1]], self.filename,
76+
self.path_save_result + data2)
77+
if self.print_train:
78+
print('Predict DONE - CPU - RMSE: %f, RAM - RMSE: %f' % (measure_scaled.score_rmse[0], measure_scaled.score_rmse[1]))
4879
save_all_models_to_csv(item, self.log_filename, self.path_save_result)
49-
save_prediction_to_csv(y_actual[:,0:1], y_predict[:,0:1], self.filename, self.path_save_result+"CPU-")
50-
save_prediction_to_csv(y_actual[:,1:2], y_predict[:,1:2], self.filename, self.path_save_result+"RAM-")
51-
save_loss_train_to_csv(loss_train, self.filename, self.path_save_result + "Error-")
52-
if self.draw:
53-
draw_predict_with_error(1, [y_actual[:,0:1], y_predict[:,0:1]], [measure.score_rmse[0], measure.score_mae[0]], self.filename, self.path_save_result+"CPU-")
54-
draw_predict_with_error(2, [y_actual[:,1:2], y_predict[:,1:2]], [measure.score_rmse[1], measure.score_mae[1]], self.filename, self.path_save_result+"RAM-")
55-
if self.print_train:
56-
print('Predict DONE - CPU - RMSE: %f, RAM - RMSE: %f' % (measure.score_rmse[0], measure.score_rmse[1]))
80+
5781
else:
58-
measure_nor = MeasureTimeSeries(y_actual_normalized, y_predict_normalized, None, number_rounding=4)
59-
measure_nor.fit()
60-
measure_denor = MeasureTimeSeries(y_actual, y_predict, None, number_rounding=4)
61-
measure_denor.fit()
62-
63-
item = [self.filename, self.time_total_train, self.time_epoch, self.time_predict, self.time_system,
64-
measure_nor.score_ev, measure_nor.score_mae, measure_nor.score_mse, measure_nor.score_msle,
65-
measure_nor.score_r2, measure_nor.score_rmse, measure_nor.score_mape[0], measure_nor.score_smape[0],
66-
measure_denor.score_ev, measure_denor.score_mae, measure_denor.score_mse, measure_denor.score_msle,
67-
measure_denor.score_r2, measure_denor.score_rmse, measure_denor.score_mape[0], measure_denor.score_smape[0]
68-
]
82+
measure_scaled = MeasureTimeSeries(y_true_scaled, y_pred_scaled, None, number_rounding=4)
83+
measure_scaled._fit__()
84+
measure_unscaled = MeasureTimeSeries(y_true, y_pred, None, number_rounding=4)
85+
measure_unscaled._fit__()
86+
87+
item = {'model_name': self.filename, 'total_time_train': self.time_total_train, 'time_epoch': self.time_epoch,
88+
'time_predict': self.time_predict, 'time_system': self.time_system,
89+
'scaled_EV': measure_scaled.score_ev, 'scaled_MSLE': measure_scaled.score_msle, 'scaled_R2': measure_scaled.score_r2,
90+
'scaled_MAE': measure_scaled.score_mae, 'scaled_MSE': measure_scaled.score_mse, 'scaled_RMSE': measure_scaled.score_rmse,
91+
'scaled_MAPE': measure_scaled.score_mape, 'scaled_SMAPE': measure_scaled.score_smape,
92+
'unscaled_EV': measure_unscaled.score_ev, 'unscaled_MSLE': measure_unscaled.score_msle, 'unscaled_R2': measure_unscaled.score_r2,
93+
'unscaled_MAE': measure_unscaled.score_mae, 'unscaled_MSE': measure_unscaled.score_mse, 'unscaled_RMSE': measure_unscaled.score_rmse,
94+
'unscaled_MAPE': measure_unscaled.score_mape, 'unscaled_SMAPE': measure_unscaled.score_smape}
95+
96+
if n_runs == 1:
97+
save_prediction_to_csv(y_true, y_pred, self.filename, self.path_save_result)
98+
save_loss_train_to_csv(loss_train, self.filename, self.path_save_result + "Error-")
99+
if self.draw:
100+
draw_predict_with_error([y_true, y_pred], [measure_unscaled.score_rmse, measure_unscaled.score_mae], self.filename, self.path_save_result)
101+
if self.print_train:
102+
print('Predict DONE - RMSE: %f, MAE: %f' % (measure_unscaled.score_rmse, measure_unscaled.score_mae))
103+
69104
save_all_models_to_csv(item, self.log_filename, self.path_save_result)
70-
save_prediction_to_csv(y_actual, y_predict, self.filename, self.path_save_result)
71-
save_loss_train_to_csv(loss_train, self.filename, self.path_save_result + "Error-")
72-
if self.draw:
73-
draw_predict_with_error(1, [y_actual, y_predict], [measure_denor.score_rmse, measure_denor.score_mae], self.filename, self.path_save_result)
74-
if self.print_train:
75-
print('Predict DONE - RMSE: %f, MAE: %f' % (measure_denor.score_rmse, measure_denor.score_mae))
76-
77-
def _save_results_ntimes_run__(self, y_actual=None, y_predict=None, y_actual_normalized=None, y_predict_normalized=None):
78-
measure_nor = MeasureTimeSeries(y_actual_normalized, y_predict_normalized, None, number_rounding=4)
79-
measure_nor.fit()
80-
measure_denor = MeasureTimeSeries(y_actual, y_predict, None, number_rounding=4)
81-
measure_denor.fit()
82-
item = [self.filename, self.time_total_train, self.time_epoch, self.time_predict, self.time_system,
83-
measure_nor.score_ev, measure_nor.score_mae, measure_nor.score_mse, measure_nor.score_msle,
84-
measure_nor.score_r2, measure_nor.score_rmse, measure_nor.score_mape[0], measure_nor.score_smape[0],
85-
measure_denor.score_ev, measure_denor.score_mae, measure_denor.score_mse, measure_denor.score_msle,
86-
measure_denor.score_r2, measure_denor.score_rmse, measure_denor.score_mape[0], measure_denor.score_smape[0]
87-
]
88-
save_all_models_to_csv(item, self.log_filename, self.path_save_result)
89105

90106
def _forecasting__(self):
91107
pass

0 commit comments

Comments
 (0)