map = mean_absolute_percentage_error(y_test, predicted, mode)
print('MAPE is ', map)
meap = median_absolute_percentage_error(y_test, predicted)
print('MEAPE is ', meap)
rmsre = mean_percentage_r_error(y_test, predicted)
print('MPRE is ', rmsre)
plot_results(predicted, ts_test, y_test, ts_train, y_train_original_part,
rms, ms, map, meap, rmsre, mode)
''' todo : denoramalize the actual and predicted data '''
print('Denormalizeing Data ....')
from denorm import denorm_v2
y_test_revert = denorm_v2(y_test, min_max_scaler)
print('-----------------------', len(y_test), len(y_test_revert))
y_train_revert = denorm_v2(y_train, min_max_scaler)
print('-----------------------', len(y_train), len(y_train_revert))
y_train_original_revert = denorm_v2(y_train_original_part, min_max_scaler)
print('-----------------------', len(y_train_original_part),
len(y_train_original_revert))
y_pred_revert = denorm_v2(predicted, min_max_scaler)
print('-----------------------', len(predicted), len(y_pred_revert))
y_test_revert = np.reshape(y_test_revert, (y_test_revert.size, ))
y_pred_revert = np.reshape(y_pred_revert, (y_pred_revert.size, ))
rms = sqrt(mean_squared_error(y_test_revert, y_pred_revert))
ms = mean_squared_error(y_test_revert, y_pred_revert)
print('RMSE is ', rms)
def test(self):
ytr = []
ypr = []
print('\n\t\t ------------------- Test staging ---------------------')
for i in range(len(X_test)):
X = X_test[i]
X = np.expand_dims(X, 3)
X = np.reshape(X, newshape=(1, X.size, 1))
Y = X
y_true = y_test[i] # y_T+1
y_true = np.expand_dims(y_true, 3)
g_in = X
print('\tshape of X is ', X.shape, 'shape of Y is ', Y.shape,
'shape of y_true is ', y_true.shape) if i == 0 else None
g_out = self.generator.predict([g_in, Y]) # which is y_hat_T+1
print('\tshape of g_out is ', g_out.shape) if i == 0 else None
g_out = np.squeeze(g_out)
y_pred = g_out[-1]
ytr.append(y_true[0][0])
ypr.append(y_pred)
from sklearn.metrics import mean_squared_error
from math import sqrt
ms = mean_squared_error(ytr, ypr)
rms = sqrt(ms)
print('MSE is ', ms)
print(' ------------------------------------')
def mean_absolute_percentage_error(y_true, y_pred):
ape = []
for k in range(len(y_true)):
# if abs(y_true[k])!=0 and k not in z1 and k not in z2:
if abs(y_pred[k]) > 1e-3 and abs(y_true[k]) > 1e-3:
ape.append(abs((y_true[k] - y_pred[k]) / y_true[k]))
# plt.hist(ape, bins='auto', color='orange')
# plt.xlabel('MAPE')
# plt.ylabel('frequency')
# plt.grid()
#
# plt.pause(3)
# plt.close()
ape = sorted(ape)
indexes = np.where(ape < np.percentile(ape, 90))[0]
ape = [ape[k] for k in indexes]
# print(ape)
return np.mean(np.array(ape)) * 100
def median_absolute_percentage_error(y_true, y_pred):
ape = []
for k in range(len(y_true)):
if abs(y_pred[k]) > 1e-3 and abs(y_true[k]) > 1e-3:
# if abs(y_true[k])!=0 and k not in z1 and k not in z2:
ape.append(abs((y_pred[k] - y_true[k]) / y_true[k]))
ape = sorted(ape)
indexes = np.where(ape < np.percentile(ape, 90))[0]
ape = [ape[k] for k in indexes]
return np.median(np.array(ape)) * 100
def mean_percentage_r_error(y_true, y_pred):
ape = []
for k in range(len(y_true)):
if abs(y_pred[k]) > 1e-3 and abs(y_true[k]) > 1e-3:
# if abs(y_true[k])!=0 and k not in z1 and k not in z2:
ape.append(pow(((y_true[k] - y_pred[k]) / y_true[k]), 2))
ape = sorted(ape)
indexes = np.where(ape < np.percentile(ape, 90))[0]
ape = [ape[k] for k in indexes]
return sqrt(np.mean(np.array(ape)))
map = mean_absolute_percentage_error(ytr, ypr)
print('MAPE is ', map)
meap = median_absolute_percentage_error(ytr, ypr)
print('MEAPE is ', meap)
rmsre = mean_percentage_r_error(ytr, ypr)
print('RMSRE is ', rmsre)
# fig = plt.figure(facecolor='white', figsize=(10, 8))
# plt.subplot(2, 1, 1)
# plt.plot(ytr, label='Test Real Data', color='orange')
# plt.legend()
# plt.subplot(2, 1, 2)
# plt.plot(ypr, label='Prediction Real Data, MAPE = %.4f%% ,\n '
# ' RMSE=%.4f , RMSRE=%.4f ' % (
# map, rms, rmsre))
# plt.legend()
# plt.savefig('/home/vacek/Cloud/cloud-predictor/NASA-HTTP/prediction/GANS/5min/resutls'
# '/imf' + str(imf_index) + '/prediction_normalize' + '.png', dpi=700)
# plt.pause(5)
# plt.close()
''' denoramalize the actual and predicted data '''
min_test, max_test, ytr_revert = denorm_v2(ytr, MaxAbsScalerObj)
min_predicted, max_predicted, ypr_revert = denorm_v2(
ypr, MaxAbsScalerObj)
ytr_revert = np.reshape(ytr_revert, (ytr_revert.size, ))
ypr_revert = np.reshape(ypr_revert, (ypr_revert.size, ))
map_denormalize = mean_absolute_percentage_error(
ytr_revert, ypr_revert)
print('MAPE in original scale is ', map_denormalize)
meap_denormalize = median_absolute_percentage_error(
ytr_revert, ypr_revert)
print('MEAPE in original scale is ', meap_denormalize)
rms_denormalize = sqrt(mean_squared_error(ytr_revert, ypr_revert))
print('RMSE in original scale is ', rms_denormalize)
rmsre_denorm = mean_percentage_r_error(ytr_revert, ypr_revert)
print(' ------------------------------------')
fig = plt.figure(facecolor='white', figsize=(10, 8))
plt.subplot(3, 1, 1)
plt.plot(ts_test, ytr_revert, label='Test Real Data', color='orange')
plt.plot(ts_test,
ypr_revert,
label='Prediction Real Data',
color='brown',
alpha=0.5)
plt.legend()
plt.subplot(3, 1, 2)
plt.plot(ts_test, ytr_revert, label='Test Real Data', color='orange')
plt.legend()
plt.subplot(3, 1, 3)
plt.plot(ts_test,
ypr_revert,
label='Prediction Real Data, MAPE = %.4f%% ,\n '
' RMSE=%.4f , RMSRE=%.4f ' %
(map_denormalize, rms_denormalize, rmsre_denorm))
plt.legend()
plt.savefig(
'/home/vacek/Cloud/cloud-predictor/NASA-HTTP/prediction/GANS-EMD/1min-Smooth/resutls'
'/imf' + str(imf_index) + '/prediction_original' + '.png',
dpi=700)
plt.pause(5)
plt.close()
print('writing to DB!')
print(len(ts_test), len(ypr_revert), len(ytr_revert), len(X_test))
for k in range(len(ts_test)):
#print(ts_test[k], ytr_revert[k], ypr_revert[k],ytr[k])
cur.execute('update nasa_http_emd_1min_copy set num_req_pred_gan=%s where imf_index=%s'
' and num_req_pred is null and ts=%s', \
(float(ypr_revert[k]), int(imf_index), int(ts_test[k])+seq_len+1))
conn.commit()
plt.legend()
plt.subplot(3, 1, 3)
plt.plot(
y_pred,
label=
'Prediction Real Data, MAPE = %.4f%% , RMSE=%.4f ,\n MEAPE=%.4f%% , RMSRE=%.4f '
% (map, rms, meap, rmsre))
plt.legend()
plt.savefig(
'/home/vacek/Cloud/cloud-predictor/Saskatchewan/prediction/1step/EMD-SVR/10min-smooth/main/results'
'/imf' + str(imf_index) + '/normalize' + '.png',
dpi=900)
plt.pause(5)
plt.close()
''' denoramalize the actual and predicted data '''
min_test, max_test, ts_test_revert = denorm_v2(y_test, MaxAbsScalerObj)
min_predicted, max_predicted, ts_predicted_revert = denorm_v2(
y_pred, MaxAbsScalerObj)
print('min_test=%s , max_test=%s', (min_test, max_test))
print('min_predicted=%s , max_predicted=%s',
(min_predicted, max_predicted))
ts_test_revert = np.reshape(ts_test_revert, (ts_test_revert.size, ))
ts_predicted_revert = np.reshape(ts_predicted_revert,
(ts_predicted_revert.size, ))
try:
map_denormalize = mean_absolute_percentage_error(
ts_test_revert, ts_predicted_revert)
print('MAPE in original scale is ', map_denormalize)
meap_denormalize = median_absolute_percentage_error(
ape = []
for k in range(len(y_true)):
if abs(y_pred[k]) > 1e-3 and abs(y_true[k]) > 1e-3:
ape.append(abs((y_pred[k] - y_true[k]) / y_true[k]))
return np.median(np.array(ape)) * 100
map = mean_absolute_percentage_error(y_test, predicted)
print('MAPE is ', map)
meap = median_absolute_percentage_error(y_test, predicted)
print('MEAPE is ', meap)
''' denoramalize the actual and predicted data '''
min_train, max_train, ts_train_revert = denorm_v2(y_train_original_part,MaxAbsScalerObj)
min_test, max_test, ts_test_revert = denorm_v2(y_test, MaxAbsScalerObj)
min_predicted, max_predicted, ts_predicted_revert = denorm_v2(predicted, MaxAbsScalerObj)
# print('min_train=%s , max_train=%s',(min_train,max_train))
# print('min_test=%s , max_test=%s', (min_test, max_test))
# print('min_predicted=%s , max_predicted=%s', (min_predicted, max_predicted))
map_denormalize = mean_absolute_percentage_error(ts_test_revert, ts_predicted_revert)
print('MAPE in original scale is ', map_denormalize)
meap_denormalize = median_absolute_percentage_error(ts_test_revert, ts_predicted_revert)
print('MEAPE in original scale is ', meap_denormalize)
rms_denormalize = sqrt(mean_squared_error(ts_test_revert, ts_predicted_revert))
print('RMSE in original scale is ', rms_denormalize)
print(' ------------------------------------')
''' saving the trained model'''
