def run_without_offloading(cell_list):
def run(cell_num):
config = Env_Config()
model_path = os.path.join(root_dir,
'offloading/output_model/deepQ_test.ckpt')
offloading = Run_Offloading(model_path, config, cell_num)
result_dict = offloading.run_test_without_RL(0)
result_array = dict_to_nparray(result_dict, cell_num)
return result_array
target_path = os.path.join(
root_dir, 'offloading/result/without_offloading_without_RL')
utility.check_path_exist(target_path)
store_path = os.path.join(target_path, 'loop_report.txt')
if os.path.exists(store_path):
os.remove(store_path)
cell_list_len = len(cell_list)
all_cell_result_array_list = []
for cell_num in cell_list:
logger.info('cell_num:{}'.format(cell_num))
result_array = run(cell_num)
all_cell_result_array_list.append(result_array)
save_report(result_array, store_path)
all_cell_result_array = np.stack(all_cell_result_array_list, axis=0)
du.save_array(all_cell_result_array,
os.path.join(target_path, 'all_cell_result_array.npy'))
all_cell_result_array = np.stack(all_cell_result_array_list, axis=0)
du.save_array(all_cell_result_array,
os.path.join(target_path, 'all_cell_result_array.npy'))
plt.ioff()
def _task_4():
'''
X: past one hour
Y: next hour's min value
'''
x_target_path = './npy/final/hour_min/testing/X'
y_target_path = './npy/final/hour_min/testing/Y'
if not os.path.exists(x_target_path):
os.makedirs(x_target_path)
if not os.path.exists(y_target_path):
os.makedirs(y_target_path)
filelist = du.list_all_input_file(root_dir + '/npy/hour_min/X')
filelist.sort()
for i, filename in enumerate(filelist):
if filename != 'training_raw_data.npy':
data_array = du.load_array(root_dir + '/npy/hour_min/X/' +
filename)
# only network activity
data_array = data_array[:, :, grid_start:grid_stop,
grid_start:grid_stop, (0, 1, -1)]
print('saving array shape:{}'.format(data_array.shape))
du.save_array(data_array,
x_target_path + '/hour_min_' + str(i))
filelist = du.list_all_input_file(root_dir + '/npy/hour_min/Y')
filelist.sort()
for i, filename in enumerate(filelist):
min_array = du.load_array(root_dir + '/npy/hour_min/Y/' + filename)
# only network activity
min_array = min_array[:, :, grid_start:grid_stop,
grid_start:grid_stop, (0, 1, -1)]
du.save_array(min_array, y_target_path + '/hour_min_' + str(i))
def _get_10mins_CDR_internet_traffic(self, grid_list, reload=True):
target_path = './npy/10min_CDR_internet_traffic_temp.npy'
source_path = os.path.join(self.config.base_dir, '10min_CDR_internet_traffic.npy')
if reload:
# TK = Prepare_Task_Data('./npy/final/')
# X_array, _ = TK.Task_max(grid_limit=[(0, 100), (0, 100)], generate_data=True) # only need max here
X_array = du.load_array(source_path)
X_array = np.transpose(X_array, (2, 3, 0, 1, 4))
array_list = []
for search_grid_id in grid_list:
# row, column = compute_row_col(grid_id)
for row_index in range(X_array.shape[0]):
for col_index in range(X_array.shape[1]):
grid_id = X_array[row_index, col_index, 0, 0, 0]
if search_grid_id == grid_id:
new_x = X_array[row_index, col_index]
new_x = new_x[:, :, (0, 1, -1)]
array_list.append(new_x) # grid_id, timestamp, internet traffic
_10mins_CDR_internet_traffic = np.stack(array_list)
logger.debug('_10mins_CDR_internet_traffic shape:{}'.format(_10mins_CDR_internet_traffic.shape)) # (grid_number, 1487, 6, 3)
du.save_array(_10mins_CDR_internet_traffic, target_path)
else:
_10mins_CDR_internet_traffic = du.load_array(target_path)
return _10mins_CDR_internet_traffic
def run_ARIMA_prediction_RL(cell_list):
def run_offloading(cell_num):
config = Env_Config()
config.features_num = 3
config.base_dir = os.path.join(root_dir,
'offloading/npy/real_prediction_ARIMA')
model_path = os.path.join(
root_dir, 'offloading/output_model/deepQ_RL_ARIMA_prediction.ckpt')
offloading = Run_Offloading(model_path, config, cell_num)
without_RL_with_offloading_result_dict = offloading.run_test_without_RL(
10)
without_RL_offloading_result_dict = offloading.run_test_without_RL(0)
logger.info(
'macro load:{} offloading_without_RL:{} without_RL_without_offloading:{}'
.format(
np.mean(
without_RL_offloading_result_dict['macro_load'][-149:]),
np.mean(without_RL_with_offloading_result_dict['energy_effi']
[-149:]),
np.mean(
without_RL_offloading_result_dict['energy_effi'][-149:])))
offloading.RL_train()
with_RL_result_dict = offloading.run_test_with_RL(reload=False)
with_RL_result_array = dict_to_nparray(with_RL_result_dict, cell_num)
# without_RL_with_offloading_result_array = dict_to_nparray(without_RL_with_offloading_result_dict)
# without_RL_offloading_result_array = dict_to_nparray(without_RL_offloading_result_dict)
offloading_plot(with_RL_result_dict,
without_RL_with_offloading_result_dict,
without_RL_offloading_result_dict)
return with_RL_result_array
plt.ion()
target_path = os.path.join(root_dir,
'offloading/result/RL_real_ARIMA_prediction')
utility.check_path_exist(target_path)
store_path = os.path.join(target_path, 'loop_report.txt')
if os.path.exists(store_path):
os.remove(store_path)
cell_list_len = len(cell_list)
all_cell_result_array_list = []
for cell_num in cell_list:
with_RL_result_array = run_offloading(cell_num)
all_cell_result_array_list.append(with_RL_result_array)
logger.info('cell_num:{} average effi mean:{}'.format(
cell_num, np.mean(with_RL_result_array[-149:, 2])))
save_report(with_RL_result_array, store_path)
all_cell_result_array = np.stack(all_cell_result_array_list, axis=0)
du.save_array(all_cell_result_array,
os.path.join(target_path, 'all_cell_result_array.npy'))
all_cell_result_array = np.stack(all_cell_result_array_list, axis=0)
du.save_array(all_cell_result_array,
os.path.join(target_path, 'all_cell_result_array.npy'))
plt.ioff()
def convert_prediction_to_non_prediction():
source_path = os.path.join(root_dir, 'offloading/npy/real_prediction')
target_path = os.path.join(root_dir, 'offloading/npy/real_without_prediction')
_10_min_traffic = du.load_array(os.path.join(source_path, '10min_CDR_internet_traffic.npy'))
hour_traffic = du.load_array(os.path.join(source_path, 'hour_traffic_array.npy'))
print('origin 10 min shape:{} origin hour shape:{}'.format(_10_min_traffic.shape, hour_traffic.shape))
_10_min_traffic = _10_min_traffic[1:] # (1485, 6, 41, 41, 3)
hour_traffic = hour_traffic[:-1] # (1485, 1, 41, 41, 8)
print('new 10 min shape:{} new hour shape:{}'.format(_10_min_traffic.shape, hour_traffic.shape))
du.save_array(_10_min_traffic, os.path.join(target_path, '10min_CDR_internet_traffic'))
du.save_array(hour_traffic, os.path.join(target_path, 'hour_traffic_array'))
def load_and_save(file_dir, target_path):
filelist = du.list_all_input_file(file_dir)
filelist.sort()
for i, filename in enumerate(filelist):
file_path = os.path.join(file_dir, filename)
data_array = du.load_array(file_path)
data_array = data_array[:, :,
grid_limit[0][0]:grid_limit[0][1],
grid_limit[1][0]:grid_limit[1][1],
(0, 1, -1)]
print('saving array shape:', data_array.shape)
du.save_array(
data_array,
os.path.join(target_path, task_name + '_' + str(i)))
def Task_max_min_avg(self,
grid_limit=[(45, 60), (45, 60)],
generate_data=False):
# print(grid_limit)
task_name = 'hour_min_avg_max'
if generate_data:
x_target_path = os.path.join(self.target_path, task_name, 'X')
y_target_path = os.path.join(self.target_path, task_name, 'Y')
if not os.path.exists(x_target_path):
os.makedirs(x_target_path)
if not os.path.exists(y_target_path):
os.makedirs(y_target_path)
X, max_Y = self.Task_max(grid_limit, generate_data)
_, min_Y = self.Task_min(grid_limit, generate_data)
_, avg_Y = self.Task_avg(grid_limit, generate_data)
min_avg_max_Y = np.zeros([
max_Y.shape[0], max_Y.shape[1], max_Y.shape[2], max_Y.shape[3],
5
]) # grid_id timestamp, min, avg, max
for i in range(max_Y.shape[0]):
for j in range(max_Y.shape[1]):
for row in range(max_Y.shape[2]):
for col in range(max_Y.shape[3]):
# print('min:{} avg:{} max:{}'.format(min_Y[i, j, row, col, 0], avg_Y[i, j, row, col, 0], max_Y[i, j, row, col, 0]))
min_avg_max_Y[i, j, row, col,
0] = min_Y[i, j, row, col,
0] # grid_id
min_avg_max_Y[i, j, row, col,
1] = min_Y[i, j, row, col,
1] # timesatemp
min_avg_max_Y[i, j, row, col,
2] = min_Y[i, j, row, col,
-1] # internet traffic
min_avg_max_Y[i, j, row, col,
3] = avg_Y[i, j, row, col,
-1] # internet traffic
min_avg_max_Y[i, j, row, col,
4] = max_Y[i, j, row, col,
-1] # internet traffic
du.save_array(X, os.path.join(x_target_path, 'min_avg_max_X'))
du.save_array(min_avg_max_Y,
os.path.join(y_target_path, 'min_avg_max_Y'))
return X, min_avg_max_Y
else:
return self._get_X_and_Y(task_name)
def _task_6():
'''
X: past one hour
Y: next 10 minutes traffic level
'''
_task_2()
x_target_path = './npy/final/10_minutes_level/testing/X'
y_target_path = './npy/final/10_minutes_level/testing/Y'
if not os.path.exists(x_target_path):
os.makedirs(x_target_path)
if not os.path.exists(y_target_path):
os.makedirs(y_target_path)
X, Y = get_X_and_Y_array(task_num=2)
Y = feature_scaling(Y, feature_range=(1, 10)) # 10 interval
Y = np.floor(Y) # 10 level
du.save_array(X, x_target_path + '/10_minutes_X')
du.save_array(Y, y_target_path + '/10_minutes_Y')
def _task_5():
'''
X: past one hour
Y: next hour's min avg max internet traffic
for multi task learning
'''
_task_4()
_task_3()
_task_1()
x_target_path = './npy/final/hour_min_avg_max/testing/X'
y_target_path = './npy/final/hour_min_avg_max/testing/Y'
if not os.path.exists(x_target_path):
os.makedirs(x_target_path)
if not os.path.exists(y_target_path):
os.makedirs(y_target_path)
max_X, max_Y = get_X_and_Y_array(task_num=1)
min_X, min_Y = get_X_and_Y_array(task_num=4)
avg_X, avg_Y = get_X_and_Y_array(task_num=3)
min_avg_max_Y = np.zeros([
max_Y.shape[0], max_Y.shape[1], max_Y.shape[2], max_Y.shape[3], 5
]) # grid_id timestamp, min, avg, max
for i in range(max_Y.shape[0]):
for j in range(max_Y.shape[1]):
for row in range(max_Y.shape[2]):
for col in range(max_Y.shape[3]):
# print('min:{} avg:{} max:{}'.format(min_Y[i, j, row, col, 0], avg_Y[i, j, row, col, 0], max_Y[i, j, row, col, 0]))
min_avg_max_Y[i, j, row, col, 0] = min_Y[i, j, row,
col, 0]
min_avg_max_Y[i, j, row, col, 1] = min_Y[i, j, row,
col, 1]
min_avg_max_Y[i, j, row, col, 2] = min_Y[i, j, row,
col, -1]
min_avg_max_Y[i, j, row, col, 3] = avg_Y[i, j, row,
col, -1]
min_avg_max_Y[i, j, row, col, 4] = max_Y[i, j, row,
col, -1]
du.save_array(max_X, x_target_path + '/min_avg_max_X')
du.save_array(min_avg_max_Y, y_target_path + '/min_avg_max_Y')
def generate_real_prediction_traffic_array():
'''
call generate_new_real_prediction_traffic_array and generate_new_10mins_CDR_internet_traffic
'''
targer_dir = os.path.join(root_dir, 'offloading/npy/real_prediction')
CNN_RNN.utility.check_path_exist(targer_dir)
hour_target_path = os.path.join(targer_dir, 'hour_traffic_array.npy')
_10mins_target_path = os.path.join(targer_dir, '10min_CDR_internet_traffic.npy')
hour_traffic = generate_new_real_prediction_traffic_array() # (1487, 1, 41, 41, 8)
_10_min_traffic = generate_new_10mins_CDR_internet_traffic() # (1487, 6, 41, 41, 3)
_10_min_traffic = _10_min_traffic[1:] # (1486, 6, 41, 41, 3)
hour_traffic = hour_traffic[:-1] # (1486, 1, 41, 41, 8)
print('hour_traffic shape:{} _10_min_traffic shape:{}'.format(hour_traffic.shape, _10_min_traffic.shape))
# for row_index in range(hour_traffic.shape[2]):
# for col_index in range(hour_traffic.shape[3]):
# print(hour_traffic[0, 0, row_index, col_index, 0])
du.save_array(hour_traffic, hour_target_path)
du.save_array(_10_min_traffic, _10mins_target_path)
def predict_MTL_train(neural, X_array, Y_array, model_path):
print(X_array.shape)
prediction_min, prediction_avg, prediction_max = neural.start_MTL_predict(
X_array, Y_array[:, :, :, :, 2:], model_path)
# real_min = Y_array[:, :, :, :, 2, np.newaxis]
# real_avg = Y_array[:, :, :, :, 3, np.newaxis]
# real_max = Y_array[:, :, :, :, 4, np.newaxis]
# print(prediction_min.shape, real_min.shape)
''' unfeature scaling'''
predict_y = np.concatenate(
(prediction_min, prediction_avg, prediction_max), axis=-1)
predict_y = un_feature_scaling(predict_y, scaler)
new_Y_array = un_feature_scaling(Y_array[:, :, :, :, 2:], scaler)
Y_array = copy(Y_array, new_Y_array)
# grid_id, timestamp, real_min, real_avg, real_max, prediciton_min, prediction_avg, prediction_max
Y_real_prediction = np.concatenate((Y_array, predict_y), axis=-1)
du.save_array(Y_real_prediction, './result/Y_real_prediction.npy')
print('-' * 20, 'task min:', '-' * 20)
compute_loss_rate(Y_array[:, :, :, :, 2, np.newaxis],
predict_y[:, :, :, :, 0, np.newaxis])
plot_predict_vs_real(Y_array[:, :, :, :, (0, 1, 2)],
predict_y[:, :, :, :, 0, np.newaxis])
print('-' * 30)
print('-' * 20, 'task avg:', '-' * 20)
compute_loss_rate(Y_array[:, :, :, :, 3, np.newaxis],
predict_y[:, :, :, :, 1, np.newaxis])
plot_predict_vs_real(Y_array[:, :, :, :, (0, 1, 3)],
predict_y[:, :, :, :, 1, np.newaxis])
print('-' * 30)
print('-' * 20, 'task max:', '-' * 20)
compute_loss_rate(Y_array[:, :, :, :, 4, np.newaxis],
predict_y[:, :, :, :, 2, np.newaxis])
plot_predict_vs_real(Y_array[:, :, :, :, (0, 1, 4)],
predict_y[:, :, :, :, 2, np.newaxis])
print('-' * 30)
def _task_3():
'''
X: past one hour
Y: next hour's avg value
'''
x_target_path = './npy/final/hour_avg/testing/X'
y_target_path = './npy/final/hour_avg/testing/Y'
if not os.path.exists(x_target_path):
os.makedirs(x_target_path)
if not os.path.exists(y_target_path):
os.makedirs(y_target_path)
filelist = du.list_all_input_file(root_dir + '/npy/hour_avg/X')
filelist.sort()
for i, filename in enumerate(filelist):
if filename != 'training_raw_data.npy':
data_array = du.load_array(root_dir + '/npy/hour_avg/X/' +
filename)
data_array = data_array[:, :, grid_start:grid_stop,
grid_start:grid_stop, (0, 1, -1)]
print('saving array shape:', data_array.shape)
du.save_array(data_array,
x_target_path + '/hour_avg_' + str(i))
# prepare y
filelist = du.list_all_input_file(root_dir + '/npy/hour_avg/Y')
filelist.sort()
for i, filename in enumerate(filelist):
avg_array = du.load_array(root_dir + '/npy/hour_avg/Y/' +
filename)
# only network activity
# avg_array = avg_array[:, :, grid_start:65, grid_start:65,
# (0, 1, -1)] # only network activity
avg_array = avg_array[:, :, grid_start:grid_stop,
grid_start:grid_stop, (0, 1, -1)]
du.save_array(avg_array,
y_target_path + '/hour_avg_' + str(i))
def _task_2():
'''
rolling 10 minutes among timeflows
X: past one hour
Y: next 10 minutes value
'''
# check target dir exist
x_target_path = './npy/final/roll_10/testing/X'
y_target_path = './npy/final/roll_10/testing/Y'
if not os.path.exists(x_target_path):
os.makedirs(x_target_path)
if not os.path.exists(y_target_path):
os.makedirs(y_target_path)
filelist_X = du.list_all_input_file(root_dir + '/npy/npy_roll/X/')
filelist_Y = du.list_all_input_file(root_dir + '/npy/npy_roll/Y/')
filelist_X.sort()
filelist_Y.sort()
for i, filename in enumerate(filelist_X):
data_array = du.load_array(root_dir + '/npy/npy_roll/X/' +
filename)
data_array = data_array[:, :, grid_start:grid_stop,
grid_start:grid_stop, (0, 1, -1)]
print('saving array shape:{}'.format(data_array.shape))
du.save_array(data_array, x_target_path + '/X_' + str(i))
for i, filename in enumerate(filelist_Y):
data_array = du.load_array(root_dir + '/npy/npy_roll/Y/' +
filename)
# only network activity
data_array = data_array[:, :, grid_start:grid_stop,
grid_start:grid_stop, (0, 1, -1)]
print(data_array[0, 0, 20, 20, 0])
print('saving array shape:{}'.format(data_array.shape))
du.save_array(data_array, y_target_path + '/Y_' + str(i))
def evaluate_CNN_RNN_without_task():
def search_grid(data_array, grid_id):
array = np.transpose(data_array, (2, 3, 0, 1, 4))
for row in range(array.shape[0]):
for col in range(array.shape[1]):
if grid_id == array[row, col, 0, 0, 0]:
return row, col
return 0, 0
def get_data():
method_result_path = os.path.join(
root_dir,
'CNN_RNN/result/CNN_RNN_without_task/all_real_prediction_traffic_array.npy'
)
result_array = du.load_array(method_result_path)
row_center_list = list(range(40, 80, 3))
col_center_list = list(range(30, 70, 3))
row_range = range(row_center_list[0] - 1, row_center_list[-1] + 1)
col_range = range(col_center_list[0] - 1, col_center_list[-1] + 1)
logger.info('row_range {}:{} col_range: {}:{}'.format(
row_range[0], row_range[-1], col_range[0], col_range[-1]))
result_array = result_array[:-1, :, :row_range[-1] - row_range[0] +
1, :col_range[-1] - col_range[0] + 1]
logger.debug('result_array shape:{}'.format(result_array.shape))
return result_array
def evaluate_performance(real, prediction):
# data_array_len = real.shape[0]
# test_real = real[9 * data_array_len // 10:]
# test_prediction = prediction[9 * data_array_len // 10:]
MAPE_loss = utility.MAPE_loss(real, prediction)
AE_loss = utility.AE_loss(real, prediction)
RMSE_loss = utility.RMSE_loss(real, prediction)
# MAPE_train = utility.MAPE_loss(train_array[:, :, :, :, 2, np.newaxis], train_array[:, :, :, :, 3, np.newaxis])
# print('test accu:{} test AE:{} test RMSE:{}'.format(1 - MAPE_test, AE_test, RMSE_test))
return 1 - MAPE_loss, AE_loss, RMSE_loss
def calculate_min_avg_max(data_array):
new_data_array = np.zeros(
(data_array.shape[0], 1, 100, 100, 8)
) # hour, 1, row, col, (grid_id, timestmap, real_min, real_avg, real_max, preidiction_min, prediction_avg, prediction_max)
data_array = np.transpose(
data_array, (0, 2, 3, 1, 4)) # hour, row, col, 10min, feature
for i in range(data_array.shape[0]):
for row in range(data_array.shape[1]):
for col in range(data_array.shape[2]):
real_max_value = np.amax(data_array[i, row, col, :, 2])
prediction_max_value = np.amax(data_array[i, row, col, :,
3])
real_min_value = np.amin(data_array[i, row, col, :, 2])
prediction_min_value = np.amin(data_array[i, row, col, :,
3])
real_avg_value = np.mean(data_array[i, row, col, :, 2])
prediction_avg_value = np.mean(data_array[i, row, col, :,
3])
grid_id = data_array[i, row, col, 0, 0]
timestamp = data_array[i, row, col, 0, 1]
row_index, col_index = utility.compute_row_col(grid_id)
new_data_array[i, 0, row_index, col_index, 0] = grid_id
new_data_array[i, 0, row_index, col_index, 1] = timestamp
new_data_array[i, 0, row_index, col_index,
2] = real_min_value
new_data_array[i, 0, row_index, col_index,
3] = real_avg_value
new_data_array[i, 0, row_index, col_index,
4] = real_max_value
new_data_array[i, 0, row_index, col_index,
5] = prediction_min_value
new_data_array[i, 0, row_index, col_index,
6] = prediction_avg_value
new_data_array[i, 0, row_index, col_index,
7] = prediction_max_value
# logger.info('grid_id:{} real:{} prediction:{}'.format(int(grid_id), real_max_value, prediction_max_value))
return new_data_array
def plot_CNN_RNN_without_task(data_arrray, grid_id, interval=6):
logger.debug('data_arrray :{}'.format(data_arrray.shape))
# plot_row = 10
# plot_col = 30
plot_row, plot_col = search_grid(data_arrray, grid_id)
# result_array_len = result_array.shape[0]
logger.info('plot_row:{} plot_col:{}'.format(plot_row, plot_col))
plot_real = data_arrray[:, :, plot_row, plot_col, 2].reshape(-1, 1)
plot_prediction = data_arrray[:, :, plot_row, plot_col,
3].reshape(-1, 1)
plt_info = data_arrray[:, :, plot_row, plot_col, :2].reshape(-1, 2)
report_func.plot_predict_vs_real(plt_info, plot_real, plot_prediction,
'CNN-RNN(*) prediction on ', interval)
def evaluate_one_grid(origin_array, real_preidction, grid_id=4867):
logger.info('origin_array shape:{} real_preidction shape:{}'.format(
origin_array.shape, real_preidction.shape))
plot_CNN_RNN_without_task(origin_array[-149:], grid_id, 24)
row, col = search_grid(real_preidction, grid_id)
accu_min, AE_min, RMSE_min = evaluate_performance(
real_preidction[-149:, :, row:row + 1, col:col + 1, 2],
real_preidction[-149:, :, row:row + 1, col:col + 1, 5])
accu_avg, AE_avg, RMSE_avg = evaluate_performance(
real_preidction[-149:, :, row:row + 1, col:col + 1, 3],
real_preidction[-149:, :, row:row + 1, col:col + 1, 6])
accu_max, AE_max, RMSE_max = evaluate_performance(
real_preidction[-149:, :, row:row + 1, col:col + 1, 4],
real_preidction[-149:, :, row:row + 1, col:col + 1, 7])
logger.info('grid id:{} MIN accu:{} AE:{} RMSE:{}'.format(
grid_id, accu_min, AE_min, RMSE_min))
logger.info('grid id:{} AVG accu:{} AE:{} RMSE:{}'.format(
grid_id, accu_avg, AE_avg, RMSE_avg))
logger.info('grid id:{} MAX accu:{} AE:{} RMSE:{}'.format(
grid_id, accu_max, AE_max, RMSE_max))
plot_CNN_RNN_without_task(
real_preidction[-149:, :, :, :, (0, 1, 4, 7)], grid_id, 2)
reload = None
result_array = get_data()
accu, AE, RMSE = evaluate_performance(result_array[-149:, :, :, :, 2],
result_array[-149:, :, :, :, 3])
logger.info('total data: test accu:{} test AE:{} test RMSE:{}'.format(
accu, AE, RMSE))
if reload:
real_preidction = calculate_min_avg_max(result_array)
du.save_array(
real_preidction,
os.path.join(
root_dir,
'CNN_RNN/result/CNN_RNN_without_task/all_real_prediction_traffic_array_split_min_avg_max.npy'
))
else:
real_preidction = du.load_array(
os.path.join(
root_dir,
'CNN_RNN/result/CNN_RNN_without_task/all_real_prediction_traffic_array_split_min_avg_max.npy'
))
print()
accu_min, AE_min, RMSE_min = evaluate_performance(
real_preidction[-149:, :, :, :, 2], real_preidction[-149:, :, :, :, 5])
accu_avg, AE_avg, RMSE_avg = evaluate_performance(
real_preidction[-149:, :, :, :, 3], real_preidction[-149:, :, :, :, 6])
accu_max, AE_max, RMSE_max = evaluate_performance(
real_preidction[-149:, :, :, :, 4], real_preidction[-149:, :, :, :, 7])
logger.info('MIN accu:{} AE:{} RMSE:{}'.format(accu_min, AE_min, RMSE_min))
logger.info('AVG accu:{} AE:{} RMSE:{}'.format(accu_avg, AE_avg, RMSE_avg))
logger.info('MAX accu:{} AE:{} RMSE:{}'.format(accu_max, AE_max, RMSE_max))
evaluate_one_grid(result_array, real_preidction, 4867)
plt.show()