def run_multiple_neural_networks(df, cfg):
# Scale data
train_and_val, test = train_test_split(df, cfg['test_size'])
scaler = MinMaxScaler().fit(train_and_val)
df[df.columns.values] = scaler.transform(df[df.columns.values].values)
if cfg['differencing']:
df = df.diff(periods=1, axis=0).dropna()
train_and_val, test = train_test_split(df, cfg['test_size'])
# train_and_val = scaler.fit_transform(train_and_val.reshape(-1, 1))
#train_and_val[train_and_val.columns.values] = scaler.fit_transform(
# train_and_val[train_and_val.columns.values].values)
#test[test.columns.values] = scaler.transform(test[test.columns.values].values)
n_columns = len(df.columns.values)
coverage_80_pi = np.zeros([n_columns, cfg['forecast_horizon']])
width_80_pi = np.zeros([n_columns, cfg['forecast_horizon']])
coverage_95_pi = np.zeros([n_columns, cfg['forecast_horizon']])
width_95_pi = np.zeros([n_columns, cfg['forecast_horizon']])
mse = np.zeros([n_columns, cfg['forecast_horizon']])
i = 0
if cfg['autoencoder']:
model = pre_training(train_and_val, cfg)
else:
model = None
for columnName, columnData in train_and_val.iteritems():
mse_sliding_window, coverage_95_pi_sliding_window, width_95_pi_sliding_window, coverage_80_pi_sliding_window, \
width_80_pi_sliding_window = pipeline(train_and_val[columnName].values.reshape(-1, 1),
test[columnName].values.reshape(-1, 1), cfg, model)
coverage_80_pi[i] = coverage_80_pi_sliding_window
width_80_pi[i] = width_80_pi_sliding_window
coverage_95_pi[i] = coverage_95_pi_sliding_window
width_95_pi[i] = width_95_pi_sliding_window
mse[i] = mse_sliding_window
i += 1
mean_mse = np.mean(mse, axis=0)
mean_coverage_95 = np.mean(coverage_95_pi, axis=0)
mean_coverage_80 = np.mean(coverage_80_pi, axis=0)
mean_width_95 = np.mean(width_95_pi, axis=0)
mean_width_80 = np.mean(width_80_pi, axis=0)
print('-----------------------------------------------------------')
print('MSE sliding window', list(mean_mse))
print('Coverage 95% PI sliding window', list(mean_coverage_95))
print('Width 95% PI sliding window', list(mean_width_95))
print('Coverage 80% PI sliding window', list(mean_coverage_80))
print('Width 80% PI sliding window', list(mean_width_80))
print('Average MSE', np.mean(mean_mse))
print('Average coverage 95% PI', np.mean(mean_coverage_95))
print('Average width 95% PI', np.mean(mean_width_95))
print('Average coverage 80% PI', np.mean(mean_coverage_80))
print('Average width 80% PI', np.mean(mean_width_80))
def arima(df, cfg):
train, test = train_test_split(df, cfg['test_size'])
scaler = MinMaxScaler(feature_range=(10 ** (-10), 1))
train['y'] = scaler.fit_transform(train.values.reshape(-1, 1))
test['y'] = scaler.transform(test.values.reshape(-1, 1))
auto_model = auto_arima(train, start_p=1, start_q=1, max_p=11, max_q=11, max_d=3, max_P=5, max_Q=5, max_D=3,
m=12, start_P=1, start_Q=1, seasonal=True, d=None, D=None, suppress_warnings=True,
stepwise=True, information_criterion='aicc')
print(auto_model.summary())
pred_arima = np.zeros([len(test) - cfg['forecast_horizon'], cfg['forecast_horizon']])
conf_int_arima_80 = np.zeros([len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
conf_int_arima_95 = np.zeros([len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
for i in range(len(test)-cfg['forecast_horizon']):
forecast_arima_95 = auto_model.predict(n_periods=cfg['forecast_horizon'],
return_conf_int=True, alpha=1-0.95)
forecast_arima_80 = auto_model.predict(n_periods=cfg['forecast_horizon'],
return_conf_int=True, alpha=1-0.8)
pred_arima[i] = forecast_arima_95[0]
conf_int_arima_80[i] = forecast_arima_80[1]
conf_int_arima_95[i] = forecast_arima_95[1]
auto_model.update(y=[test.values[i]])
# Store results
mse_arima, coverage_arima_95, coverage_arima_80, width_arima_95, width_arima_80 = [], [], [], [], []
for i in range(cfg['forecast_horizon']):
# ARIMA mean squared error (MSE):
mse_arima.append(mean_squared_error(test[i:len(test)-cfg['forecast_horizon']+i], pred_arima[:, i]))
# ARIMA 80% PI
coverage_arima_80.append(compute_coverage(upper_limits=conf_int_arima_80[:, i, 1],
lower_limits=conf_int_arima_80[:, i, 0],
actual_values=test.values[i:len(test) - cfg['forecast_horizon'] + i]))
width_arima_80.append(np.mean(conf_int_arima_80[:, i, 1] - conf_int_arima_80[:, i, 0], axis=0))
# ARIMA 95% PI
coverage_arima_95.append(compute_coverage(upper_limits=conf_int_arima_95[:, i, 1],
lower_limits=conf_int_arima_95[:, i, 0],
actual_values=test.values[i:len(test)-cfg['forecast_horizon']+i]))
width_arima_95.append(np.mean(conf_int_arima_95[:, i, 1] - conf_int_arima_95[:, i, 0], axis=0))
print('================ ARIMA =================')
print('Mean MSE', np.mean(mse_arima))
print('MSE sliding window', mse_arima)
print('Coverage of 80% PI sliding window', coverage_arima_80)
print('Width of 80% PI sliding window', width_arima_80)
print('Coverage of 95% PI sliding window', coverage_arima_95)
print('Width of 95% PI sliding window', width_arima_95)
return mse_arima, coverage_arima_80, coverage_arima_95, width_arima_80, width_arima_95
def pre_training(train_and_val, cfg):
# Train autoencoder as pre training
# train_and_val, test = train_test_split(df, cfg['test_size'])
# scaler = MinMaxScaler()
# train_and_val = scaler.fit_transform(train_and_val.reshape(-1, 1))
# train_and_val[train_and_val.columns.values] = scaler.fit_transform(train_and_val[train_and_val.columns.values].values)
train, val = train_test_split(train_and_val, cfg['validation_size'])
train_x = []
train_y = []
validation_x = []
validation_y = []
for name, values in train.iteritems():
x, y = split_sequence(values.values.reshape(-1, 1), cfg)
val_x, val_y = split_sequence(
np.concatenate([values[-cfg['sequence_length']:],
val[name]]).reshape(-1, 1), cfg)
train_x.append(x)
train_y.append(y)
validation_x.append(val_x)
validation_y.append(val_y)
train_x = np.asarray(train_x)
train_x = train_x.reshape([
train_x.shape[0] * train_x.shape[1], train_x.shape[2], train_x.shape[3]
])
train_y = np.asarray(train_y)
train_y = train_y.reshape(
[train_y.shape[0] * train_y.shape[1], train_y.shape[2]])
validation_x = np.asarray(validation_x)
validation_x = validation_x.reshape([
validation_x.shape[0] * validation_x.shape[1], validation_x.shape[2],
validation_x.shape[3]
])
validation_y = np.asarray(validation_y)
validation_y = validation_y.reshape(
[validation_y.shape[0] * validation_y.shape[1], validation_y.shape[2]])
# encoder, decoder, cfg = build_autoencoder(train_x, cfg, weights='weights//pretrained_encoder.hdf5')
# If using an encoder, extract features from training data,
model = train_model(train_x, train_y, cfg, validation_x, validation_y)
# Test autoencoder on holdout data
#encoder_test = data.x_test
#predictions = decoder.predict(encoder_test)
#mse = 0
#for i in range(len(predictions)):
# mse += mean_squared_error(encoder_test[i], predictions[i])
#print('Test mean mse:', mse/len(predictions))
return model
def pipeline(df, cfg):
train_and_val, test = train_test_split(df, cfg['test_size'])
scaler = MinMaxScaler()
train_and_val = scaler.fit_transform(train_and_val.reshape(-1, 1))
test = scaler.transform(test.reshape(-1, 1))
print('Length train', len(train_and_val))
print('Length test', len(test))
train, val = train_test_split(train_and_val, cfg['validation_size'])
train_x, train_y = split_sequence(train, cfg)
val_x, val_y = split_sequence(np.concatenate([train[-cfg['sequence_length']:], val]), cfg)
print('trainx', len(train_x))
print('val', len(val))
# If using an encoder, extract features from training data,
model = train_model(train_x, train_y, cfg, val_x, val_y)
# Compute inherent noise on validation set
history = [x for x in train]
y_hat = np.zeros([len(val), train_y.shape[1]])
for i in range(len(val)):
x_input = np.array(history[-cfg['sequence_length']:]).reshape((1, cfg['sequence_length'], 1))
y_hat[i] = model.predict(x_input)[0]
history.append(val[i])
inherent_noise = np.zeros(cfg['forecasting_horizon'])
for i in range(cfg['forecasting_horizon']):
inherent_noise[i] = mean_squared_error(val[i:], y_hat[:-i or None, 0])
print('Validation mse: ', inherent_noise)
# Predict sequence over testing set using Monte Carlo dropout with n forward passes
mse_sliding, coverage_95_pi, width_95_pi, coverage_80_pi, width_80_pi = sliding_monte_carlo_forecast(train_and_val,
test, model,
cfg,
inherent_noise)
return mse_sliding, coverage_95_pi, width_95_pi, coverage_80_pi, width_80_pi
def pipeline_baseline(df, cfg, model='arima'):
n_columns = len(df.columns.values)
coverage_80_pi = np.zeros([n_columns, cfg['forecast_horizon']])
width_80_pi = np.zeros([n_columns, cfg['forecast_horizon']])
coverage_95_pi = np.zeros([n_columns, cfg['forecast_horizon']])
width_95_pi = np.zeros([n_columns, cfg['forecast_horizon']])
mse = np.zeros([n_columns, cfg['forecast_horizon']])
train_and_val, test = train_test_split(df, cfg['test_size'])
scaler = MinMaxScaler(feature_range=(10**(-10), 1)).fit(train_and_val)
df[df.columns.values] = scaler.transform(df[df.columns.values].values)
print(train_and_val)
print(df)
i = 0
if cfg['differencing']:
df = df.diff(periods=1, axis=0).dropna()
for name, values in df.iteritems():
single_time_series = pd.DataFrame(data=values.values.reshape(-1, 1),
index=values.index,
columns=['y'])
if model == 'arima':
mse_sliding_window, coverage_80_pi_sliding_window, coverage_95_pi_sliding_window, \
width_80_pi_sliding_window, width_95_pi_sliding_window = arima(single_time_series, cfg)
else:
mse_sliding_window, coverage_80_pi_sliding_window, coverage_95_pi_sliding_window, \
width_80_pi_sliding_window, width_95_pi_sliding_window = exponential_smoothing(single_time_series, cfg)
# baseline_models(single_time_series, cfg)
coverage_80_pi[i] = coverage_80_pi_sliding_window
width_80_pi[i] = width_80_pi_sliding_window
coverage_95_pi[i] = coverage_95_pi_sliding_window
width_95_pi[i] = width_95_pi_sliding_window
mse[i] = mse_sliding_window
i += 1
mean_mse = np.mean(mse, axis=0)
mean_coverage_95 = np.mean(coverage_95_pi, axis=0)
mean_coverage_80 = np.mean(coverage_80_pi, axis=0)
mean_width_95 = np.mean(width_95_pi, axis=0)
mean_width_80 = np.mean(width_80_pi, axis=0)
print('------------------', model, '-------------------------')
print('MSE sliding window', list(mean_mse))
print('Coverage 80% PI sliding window', list(mean_coverage_80))
print('Width 80% PI sliding window', list(mean_width_80))
print('Coverage 95% PI sliding window', list(mean_coverage_95))
print('Width 95% PI sliding window', list(mean_width_95))
print('Average MSE', np.mean(mean_mse))
print('Average coverage 80% PI', np.mean(mean_coverage_80))
print('Average width 80% PI', np.mean(mean_width_80))
print('Average coverage 95% PI', np.mean(mean_coverage_95))
print('Average width 95% PI', np.mean(mean_width_95))
def exponential_smoothing(df, cfg):
train, test = train_test_split(df, cfg['test_size'])
scaler = MinMaxScaler(feature_range=(10 ** (-10), 1))
train['y'] = scaler.fit_transform(train.values.reshape(-1, 1))
test['y'] = scaler.transform(test.values.reshape(-1, 1))
trends = [None, 'add', 'add_damped']
seasons = [None, 'add', 'mul']
best_model_parameters = [None, None, False] # trend, season, damped
best_aicc = np.inf
for trend in trends:
for season in seasons:
if trend == 'add_damped':
trend = 'add'
damped = True
else:
damped = False
model_es = ExponentialSmoothing(train, seasonal_periods=12,
trend=trend, seasonal=season,
damped=damped)
model_es = model_es.fit(optimized=True)
if model_es.aicc < best_aicc:
best_model_parameters = [trend, season, damped]
best_aicc = model_es.aicc
model_es = ExponentialSmoothing(train, seasonal_periods=12,
trend=best_model_parameters[0], seasonal=best_model_parameters[1],
damped=best_model_parameters[2])
model_es = model_es.fit(optimized=True)
print(model_es.params)
print('ETS: T=', best_model_parameters[0], ', S=', best_model_parameters[1], ', damped=', best_model_parameters[2])
print('AICc', model_es.aicc)
residual_variance = model_es.sse / len(train - 2)
var = []
alpha = model_es.params['smoothing_level']
beta = model_es.params['smoothing_slope']
gamma = model_es.params['smoothing_seasonal']
for j in range(cfg['forecast_horizon']):
s = 12
h = j+1
k = int((h-1)/s)
if best_model_parameters[1] == 'add':
if best_model_parameters[0] == 'add':
var.append(residual_variance * (1 + (h - 1) * (alpha**2 + alpha*h*beta + h / 6 * (2 * h - 1) * beta ** 2)
+ k*gamma*(2*alpha + gamma + beta*s*(k + 1))))
else:
var.append(
residual_variance * (1 + (h - 1) * alpha ** 2 + k * gamma * (2 * alpha + gamma)))
elif best_model_parameters[1] == 'mul':
var.append(residual_variance*h)
else:
if best_model_parameters[0] == 'add':
var.append(
residual_variance*(1 + (h - 1)*(alpha ** 2 + alpha * h * beta + h / 6 * (2 * h - 1) * beta ** 2)))
else:
var.append(residual_variance * (1 + (h - 1) * alpha ** 2))
pred_es = np.zeros([len(test) - cfg['forecast_horizon'], cfg['forecast_horizon']])
conf_int_es_80 = np.zeros([len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
conf_int_es_95 = np.zeros([len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
for i in range(len(test) - cfg['forecast_horizon']):
pred_es[i] = model_es.forecast(steps=cfg['forecast_horizon'] + i)[-cfg['forecast_horizon']:]
conf_int_es_80[i, :, 0] = pred_es[i] - 1.28 * np.sqrt(var)
conf_int_es_80[i, :, 1] = pred_es[i] + 1.28 * np.sqrt(var)
conf_int_es_95[i, :, 0] = pred_es[i] - 1.96 * np.sqrt(var)
conf_int_es_95[i, :, 1] = pred_es[i] + 1.96 * np.sqrt(var)
# Store results
mse_es, coverage_es_95, coverage_es_80, width_es_95, width_es_80 = [], [], [], [], []
for i in range(cfg['forecast_horizon']):
# Exponential Smoothing MSE
mse_es.append(mean_squared_error(test[i:len(test) - cfg['forecast_horizon'] + i], pred_es[:, i]))
# Exponential Smoothing 80% PI
coverage_es_80.append(compute_coverage(upper_limits=conf_int_es_80[:, i, 1],
lower_limits=conf_int_es_80[:, i, 0],
actual_values=test.values[i:len(test) - cfg['forecast_horizon'] + i]))
width_es_80.append(np.mean(conf_int_es_80[:, i, 1] - conf_int_es_80[:, i, 0], axis=0))
# Exponential Smoothing 95% PI
coverage_es_95.append(compute_coverage(upper_limits=conf_int_es_95[:, i, 1],
lower_limits=conf_int_es_95[:, i, 0],
actual_values=test.values[i:len(test) - cfg['forecast_horizon'] + i]))
width_es_95.append(np.mean(conf_int_es_95[:, i, 1] - conf_int_es_95[:, i, 0], axis=0))
print('================ ES ====================')
print('MSE sliding window', mse_es)
print('Mean MSE', np.mean(mse_es))
print('Coverage of 80% PI sliding window', coverage_es_80)
print('Width of 80% PI sliding window', width_es_80)
print('Coverage of 95% PI sliding window', coverage_es_95)
print('Width of 95% PI sliding window', width_es_95)
return mse_es, coverage_es_80, coverage_es_95, width_es_80, width_es_95
def baseline_models(df, coverage, cfg):
train, test = train_test_split(df, cfg['test_size'])
scaler = MinMaxScaler(feature_range=(10**(-10), 1))
train['y'] = scaler.fit_transform(train.values.reshape(-1, 1))
test['y'] = scaler.transform(test.values.reshape(-1, 1))
trend = None
seasonal = 'add'
model_es = ExponentialSmoothing(train, seasonal_periods=12,
trend=trend, seasonal=seasonal, damped=False)
model_es = model_es.fit(optimized=True)
print('ETS: T=', trend, ', S=', seasonal)
print('AICc', model_es.aicc)
residual_variance = model_es.sse/len(train-2)
var = []
alpha = model_es.params['smoothing_level']
beta = model_es.params['smoothing_slope']
gamma = model_es.params['smoothing_seasonal']
for j in range(cfg['forecast_horizon']):
s = 12
h = j+1
k = int((h-1)/s)
#var.append(residual_variance*(1+j*alpha**2*(1+(j+1)*beta+(j+1)/6*(2*(j+1)-1)*beta**2)
# + 12*(gamma**2*(1-alpha)**2)+alpha*gamma*(1-alpha)*(2+cfg['forecast_horizon']*beta*13)))
#var.append(residual_variance*(1+(h-1)*alpha**2*(1+h*beta + h/6*(2*h-1)*beta**2)
# + k*(gamma**2*(1-alpha)**2 + alpha*gamma*(1-alpha)*(2+k*beta*(s+1)))))
if seasonal == 'add':
if trend == 'add':
var.append(residual_variance * (1 + (h - 1) * (alpha**2 + alpha*h*beta + h / 6 * (2 * h - 1) * beta ** 2)
+ k*gamma*(2*alpha + gamma + beta*s*(k + 1))))
else:
var.append(
residual_variance * (1 + (h - 1) * alpha ** 2 + k * gamma * (2 * alpha + gamma)))
else:
if trend == 'add':
var.append(
residual_variance*(1 + (h - 1)*(alpha ** 2 + alpha * h * beta + h / 6 * (2 * h - 1) * beta ** 2)))
else:
var.append(residual_variance * (1 + (h - 1) * alpha ** 2))
auto_model = auto_arima(train, start_p=1, start_q=1, max_p=11, max_q=11, max_d=3, max_P=5, max_Q=5, max_D=3,
m=12, start_P=1, start_Q=1, seasonal=True, d=None, D=None, suppress_warnings=True,
stepwise=True, information_criterion='aicc')
print(auto_model.summary())
pred_es = np.zeros([len(test)-cfg['forecast_horizon'], cfg['forecast_horizon']])
conf_int_es = np.zeros([len(test)-cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
pred_arima = np.zeros([len(test) - cfg['forecast_horizon'], cfg['forecast_horizon']])
conf_int_arima = np.zeros([len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
for i in range(len(test)-cfg['forecast_horizon']):
forecast_arima = auto_model.predict(n_periods=cfg['forecast_horizon'],
return_conf_int=True, alpha=1-coverage)
#pred_es[i] = model_es.predict(start=df.index[-len(test-i)], end=df.index[-len(test+cfg['forecast_horizon']-i)])
pred_es[i] = model_es.forecast(steps=cfg['forecast_horizon']+i)[-cfg['forecast_horizon']:]
#for j in range(cfg['forecast_horizon']):
conf_int_es[i, :, 0] = pred_es[i]-st.norm.ppf(1-(1-coverage)/2)*np.sqrt(var)
conf_int_es[i, :, 1] = pred_es[i]+st.norm.ppf(1-(1-coverage)/2)*np.sqrt(var)
pred_arima[i] = forecast_arima[0]
conf_int_arima[i] = forecast_arima[1]
auto_model.update(y=[test.values[i]])
"""
t = np.linspace(1, cfg['forecast_horizon'], cfg['forecast_horizon'])
plt.figure()
plt.title("Time Series Forecasting")
plt.plot(t, pred_es[i], label='Predicted')
plt.plot(t, test[i:cfg['forecast_horizon'] + i], label='True')
plt.fill_between(t, conf_int_es[i, :, 0], conf_int_es[i, :, 1],
alpha=0.2, edgecolor='#CC4F1B', facecolor='#FF9848', label='95%-PI')
plt.legend()
plt.show()
"""
mse_arima, coverage_arima, width_arima = [], [], []
mse_es, coverage_es, width_es = [], [], []
for i in range(cfg['forecast_horizon']):
mse_arima.append(mean_squared_error(test[i:len(test)-cfg['forecast_horizon']+i], pred_arima[:, i]))
coverage_arima.append(compute_coverage(upper_limits=conf_int_arima[:, i, 1],
lower_limits=conf_int_arima[:, i, 0],
actual_values=test.values[i:len(test)-cfg['forecast_horizon']+i]))
width_arima.append(np.mean(conf_int_arima[:, i, 1]-conf_int_arima[:, i, 0], axis=0))
mse_es.append(mean_squared_error(test[i:len(test) - cfg['forecast_horizon'] + i], pred_es[:, i]))
coverage_es.append(compute_coverage(upper_limits=conf_int_es[:, i, 1],
lower_limits=conf_int_es[:, i, 0],
actual_values=test.values[i:len(test) - cfg['forecast_horizon'] + i]))
width_es.append(np.mean(conf_int_es[:, i, 1] - conf_int_es[:, i, 0], axis=0))
print('ARIMA')
print('MSE sliding window', mse_arima)
print('Coverage', coverage*100, 'PI sliding window', coverage_arima)
print('Width', coverage*100, 'PI sliding window', width_arima)
print(np.mean(mse_arima))
print('ES')
print('MSE sliding window', mse_es)
print('Coverage', coverage * 100, 'PI sliding window', coverage_es)
print('Width', coverage * 100, 'PI sliding window', width_es)
print(np.mean(mse_es))
return mse_arima, coverage_arima, width_arima
def baseline_models(df, cfg):
train, test = train_test_split(df['y'], cfg['test_size'])
model_es = ExponentialSmoothing(train,
seasonal_periods=12,
trend='add',
seasonal='add')
model_es = model_es.fit(optimized=True)
pred_es = model_es.predict(start=df.index[-len(test)], end=df.index[-1])
auto_model = auto_arima(train,
start_p=1,
start_q=1,
max_p=3,
max_q=3,
m=12,
start_P=1,
start_Q=1,
seasonal=True,
d=1,
D=1,
suppress_warnings=True,
stepwise=True)
print('Auto arima', auto_model.aic())
print(auto_model.summary())
forecast_arima = auto_model.predict(n_periods=len(test),
return_conf_int=True,
alpha=0.05)
pred_arima = forecast_arima[0]
conf_int_95_arima = forecast_arima[1]
forecast_arima = auto_model.predict(n_periods=len(test),
return_conf_int=True,
alpha=0.2)
conf_inf_80_arima = forecast_arima[1]
coverage_95pi = compute_coverage(upper_limits=conf_int_95_arima[:, 1],
lower_limits=conf_int_95_arima[:, 0],
actual_values=test)
coverage_80pi = compute_coverage(upper_limits=conf_inf_80_arima[:, 1],
lower_limits=conf_inf_80_arima[:, 0],
actual_values=test)
print('ARIMA 95%-prediction interval coverage: ', coverage_95pi)
print('ARIMA 80%-prediction interval coverage: ', coverage_80pi)
# model_arima = SARIMAX(df['y'].iloc[:-test_size], order=(1, 1, 0), seasonal_order=(0, 1, 0, 12))
# model_arima = model_arima.fit(full_output=False, disp=False)
# print('Not auto arima', model_arima.aic)
# pred_arima = model_arima.predict(start=df.index[int(len(df)*(1-cfg['test_size'])+1)], end=df.index[-1])
# forecast_arima = model_arima.forecast(steps=int(len(df)*cfg['test_size']))
pred_es = np.asarray(pred_es)
pred_arima = np.asarray(pred_arima)
x_data = np.linspace(1, len(df), len(df))
x_predictions = np.linspace(len(train) + 1, len(df), len(test))
plt.figure()
plt.title("SARIMA Time Series Forecasting")
plt.plot(x_data, df, label='Data')
plt.plot(x_predictions, pred_arima, label='SARIMA')
plt.plot(x_predictions, pred_es, label='Exponential Smoothing')
plt.fill_between(x_predictions,
conf_inf_80_arima[:, 0],
conf_inf_80_arima[:, 1],
alpha=0.5,
edgecolor='#CC4F1B',
facecolor='#FF9848',
label='80%-PI')
plt.fill_between(x_predictions,
conf_int_95_arima[:, 0],
conf_int_95_arima[:, 1],
alpha=0.2,
edgecolor='#CC4F1B',
facecolor='#FF9848',
label='95%-PI')
plt.legend()
plt.show()
return pred_arima, pred_es
def pipeline(df, cfg):
train_and_val, test = train_test_split(df, cfg['test_size'])
print('Length train', len(train_and_val))
print('Length test', len(test))
train, val = train_test_split(train_and_val, cfg['validation_size'])
train_x, train_y = split_sequence(train, cfg)
val_x, val_y = split_sequence(
np.concatenate([train[-cfg['sequence_length']:], val]), cfg)
# If using an encoder, extract features from training data,
model = train_model(train_x, train_y, cfg, val_x, val_y)
# Compute inherent noise on validation set
history = [x for x in train]
y_hat = np.zeros([len(val), train_y.shape[1]])
for i in range(len(val)):
x_input = np.array(history[-cfg['sequence_length']:]).reshape(
(1, cfg['sequence_length'], 1))
y_hat[i] = model.predict(x_input)[0]
history.append(val[i])
inherent_noise = np.zeros(cfg['forecasting_horizon'])
print(y_hat.shape)
print(val.shape)
"""
plt.figure()
plt.plot(np.linspace(1, len(val), len(val)), val, label='Val')
plt.plot(np.linspace(1, len(val), len(val)), y_hat, label='Pred')
plt.legend()
plt.show()
"""
for i in range(cfg['forecasting_horizon']):
inherent_noise[i] = mean_squared_error(val[i:], y_hat[:-i or None, 0])
print('Validation mse: ', inherent_noise)
# Predict sequence over testing set using Monte Carlo dropout with n forward passes
# train_x, train_y = split_sequence(train_and_val, cfg)
# model = train_model(train_x, train_y, cfg)
# coverage_95_pi_sliding_window, width_95_pi_sliding_window, mse_sliding_window = sliding_monte_carlo_forecast(train_and_val, test, model, cfg, inherent_noise)
prediction_sequence = monte_carlo_forecast(train_and_val, test, model, cfg)
# Compute mean and uncertainty for the Monte Carlo estimates
mc_mean = np.zeros(
[prediction_sequence.shape[1], prediction_sequence.shape[2]])
mc_uncertainty = np.zeros(
[prediction_sequence.shape[1], prediction_sequence.shape[2]])
for i in range(cfg['forecasting_horizon']):
mc_mean[:, i] = np.mean(prediction_sequence[:, :, i], axis=0)
mc_uncertainty[:, i] = np.var(prediction_sequence[:, :, i], axis=0)
# Add inherent noise and uncertainty obtained from Monte Carlo samples
print(np.mean(inherent_noise))
print(np.mean(mc_uncertainty))
total_uncertainty = np.sqrt(inherent_noise + mc_uncertainty)
# estimate prediction error
mse = mean_squared_error(test, mc_mean)
print(' > %.5f' % mse)
# Compute quantiles of the Monte Carlo estimates
for i in range(cfg['forecasting_horizon']):
coverage_80pi = compute_coverage(
upper_limits=mc_mean[:, i] + 1.28 * total_uncertainty[:, i],
lower_limits=mc_mean[:, i] - 1.28 * total_uncertainty[:, i],
actual_values=test)
coverage_95pi = compute_coverage(
upper_limits=mc_mean[:, i] + 1.96 * total_uncertainty[:, i],
lower_limits=mc_mean[:, i] - 1.96 * total_uncertainty[:, i],
actual_values=test)
# print('80%-prediction interval coverage: ', i, coverage_80pi)
# print('95%-prediction interval coverage: ', i, coverage_95pi)
return prediction_sequence, mc_mean, total_uncertainty, mse, coverage_80pi, coverage_95pi, inherent_noise
def walk_forward_validation(train_and_val, test, cfg):
train, val = train_test_split(train_and_val, cfg['validation_size'])
train_x, train_y = split_multiple_sequences(train, cfg)
val_x, val_y = split_multiple_sequences(val, cfg)
# If using an encoder, extract features from training data,
model = train_model(train_x, train_y, cfg, val_x, val_y)
# Compute inherent noise on validation set
y_hat = np.zeros(
[len(val),
len(val[0]) - cfg['sequence_length'], train_y.shape[1]])
for i in range(len(val)):
history = [x for x in val[i, :cfg['sequence_length']]]
for j in range(len(val[i]) - cfg['sequence_length']):
x_input = np.array(history[-cfg['sequence_length']:]).reshape(
(1, cfg['sequence_length'], 1))
y_hat[i, j] = model.predict(x_input)[0]
history.append(val[i, j + cfg['sequence_length']])
inherent_noise = np.zeros(cfg['forecasting_horizon'])
print(y_hat.shape)
print(val.shape)
plt.figure()
plt.plot(val[0, cfg['sequence_length']:])
plt.plot(y_hat[0])
plt.show()
for i in range(cfg['forecasting_horizon']):
inherent_noise[i] = measure_rmse(
val[:, i + cfg['sequence_length']:].flatten(),
y_hat[:, :, -i or None, 0].flatten())
print('Validation mse: ', inherent_noise**2)
# Predict sequence over testing set using Monte Carlo dropout with n forward passes
# train_x, train_y = split_sequence(train_and_val, cfg)
# model = train_model(train_x, train_y, cfg)
prediction_sequence = monte_carlo_forecast(test, model, cfg,
inherent_noise)
# Compute mean and uncertainty for the Monte Carlo estimates
mc_mean = np.zeros(
[prediction_sequence.shape[1], prediction_sequence.shape[2]])
mc_uncertainty = np.zeros(
[prediction_sequence.shape[1], prediction_sequence.shape[2]])
for i in range(cfg['forecasting_horizon']):
mc_mean[:, i] = prediction_sequence[:, :, i].mean(axis=0)
mc_uncertainty[:, i] = prediction_sequence[:, :, i].std(axis=0)
# Add inherent noise and uncertainty obtained from Monte Carlo samples
print(np.mean(inherent_noise))
print(np.mean(mc_uncertainty))
total_uncertainty = np.sqrt(inherent_noise**2 + mc_uncertainty**2)
# estimate prediction error
mse = mean_squared_error(test, mc_mean)
print(' > %.5f' % mse)
# Compute quantiles of the Monte Carlo estimates
for i in range(cfg['forecasting_horizon']):
coverage_80pi = compute_coverage(
upper_limits=mc_mean[:, i] + 1.28 * total_uncertainty[:, i],
lower_limits=mc_mean[:, i] - 1.28 * total_uncertainty[:, i],
actual_values=test)
coverage_95pi = compute_coverage(
upper_limits=mc_mean[:, i] + 1.96 * total_uncertainty[:, i],
lower_limits=mc_mean[:, i] - 1.96 * total_uncertainty[:, i],
actual_values=test)
# print('80%-prediction interval coverage: ', i, coverage_80pi)
# print('95%-prediction interval coverage: ', i, coverage_95pi)
return prediction_sequence, mc_mean, total_uncertainty, mse, coverage_80pi, coverage_95pi, inherent_noise**2
def baseline_models(df, cfg):
result = adfuller(df['y'].values)
print('ADF Statistic: %f' % result[0])
print('p-value: %f' % result[1])
# df = df.diff(periods=1).dropna()
# result = adfuller(df['y'].values)
# print('ADF Statistic: %f' % result[0])
# print('p-value: %f' % result[1])
train, test = train_test_split(df['y'], cfg['test_size'])
# scaler = MinMaxScaler()
# train['y'] = scaler.fit_transform(train.values.reshape(-1, 1))
# test['y'] = scaler.transform(test.values.reshape(-1, 1))
trends = [None, 'add', 'add_damped']
seasons = [None, 'add', 'mul']
best_model_parameters = [None, None, False] # trend, season, damped
best_aicc = np.inf
for trend in trends:
for season in seasons:
if trend == 'add_damped':
trend = 'add'
damped = True
else:
damped = False
model_es = ExponentialSmoothing(train,
seasonal_periods=52,
trend=trend,
seasonal=season,
damped=damped)
model_es = model_es.fit(optimized=True)
if model_es.aicc < best_aicc:
best_model_parameters = [trend, season, damped]
best_aicc = model_es.aicc
model_es = ExponentialSmoothing(train,
seasonal_periods=52,
trend=best_model_parameters[0],
seasonal=best_model_parameters[1],
damped=best_model_parameters[2])
model_es = model_es.fit(optimized=True)
print('ETS: T=', best_model_parameters[0], ', S=',
best_model_parameters[1], ', damped=', best_model_parameters[2])
print('AICc', model_es.aicc)
residual_variance = model_es.sse / len(train - 2)
var = []
alpha = model_es.params['smoothing_level']
beta = model_es.params['smoothing_slope']
gamma = model_es.params['smoothing_seasonal']
for j in range(cfg['forecast_horizon']):
s = 12
h = j + 1
k = int((h - 1) / s)
#var.append(residual_variance*(1+j*alpha**2*(1+(j+1)*beta+(j+1)/6*(2*(j+1)-1)*beta**2)
# + 12*(gamma**2*(1-alpha)**2)+alpha*gamma*(1-alpha)*(2+cfg['forecast_horizon']*beta*13)))
#var.append(residual_variance*(1+(h-1)*alpha**2*(1+h*beta + h/6*(2*h-1)*beta**2)
# + k*(gamma**2*(1-alpha)**2 + alpha*gamma*(1-alpha)*(2+k*beta*(s+1)))))
var.append(residual_variance *
(1 + (h - 1) * (alpha**2 + alpha * h * beta + h / 6 *
(2 * h - 1) * beta**2) + k * gamma *
(2 * alpha + gamma + beta * s * (k + 1))))
auto_model = auto_arima(train,
start_p=1,
start_q=1,
max_p=3,
max_q=3,
m=52,
start_P=1,
start_Q=1,
seasonal=True,
d=1,
D=1,
suppress_warnings=True,
stepwise=True)
print(auto_model.summary())
pred_es = np.zeros(
[len(test) - cfg['forecast_horizon'], cfg['forecast_horizon']])
conf_int_es_80 = np.zeros(
[len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
conf_int_es_95 = np.zeros(
[len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
pred_arima = np.zeros(
[len(test) - cfg['forecast_horizon'], cfg['forecast_horizon']])
conf_int_arima_80 = np.zeros(
[len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
conf_int_arima_95 = np.zeros(
[len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
for i in range(len(test) - cfg['forecast_horizon']):
forecast_arima_95 = auto_model.predict(
n_periods=cfg['forecast_horizon'],
return_conf_int=True,
alpha=1 - 0.95)
forecast_arima_80 = auto_model.predict(
n_periods=cfg['forecast_horizon'],
return_conf_int=True,
alpha=1 - 0.8)
pred_es[i] = model_es.forecast(steps=cfg['forecast_horizon'] +
i)[-cfg['forecast_horizon']:]
conf_int_es_80[i, :, 0] = pred_es[i] - 1.28 * np.sqrt(var)
conf_int_es_80[i, :, 1] = pred_es[i] + 1.28 * np.sqrt(var)
conf_int_es_95[i, :, 0] = pred_es[i] - 1.96 * np.sqrt(var)
conf_int_es_95[i, :, 1] = pred_es[i] + 1.96 * np.sqrt(var)
pred_arima[i] = forecast_arima_95[0]
conf_int_arima_80[i] = forecast_arima_80[1]
conf_int_arima_95[i] = forecast_arima_95[1]
auto_model.update(y=[test.values[i]])
# Store results
mse_arima, coverage_arima_95, coverage_arima_80, width_arima_95, width_arima_80 = [], [], [], [], []
mse_es, coverage_es_95, coverage_es_80, width_es_95, width_es_80 = [], [], [], [], []
for i in range(cfg['forecast_horizon']):
# ARIMA mean squared error (MSE):
mse_arima.append(
mean_squared_error(test[i:len(test) - cfg['forecast_horizon'] + i],
pred_arima[:, i]))
# ARIMA 80% PI
coverage_arima_80.append(
compute_coverage(
upper_limits=conf_int_arima_80[:, i, 1],
lower_limits=conf_int_arima_80[:, i, 0],
actual_values=test.values[i:len(test) -
cfg['forecast_horizon'] + i]))
width_arima_80.append(
np.mean(conf_int_arima_80[:, i, 1] - conf_int_arima_80[:, i, 0],
axis=0))
# ARIMA 95% PI
coverage_arima_95.append(
compute_coverage(
upper_limits=conf_int_arima_95[:, i, 1],
lower_limits=conf_int_arima_95[:, i, 0],
actual_values=test.values[i:len(test) -
cfg['forecast_horizon'] + i]))
width_arima_95.append(
np.mean(conf_int_arima_95[:, i, 1] - conf_int_arima_95[:, i, 0],
axis=0))
# Exponential Smoothing MSE
mse_es.append(
mean_squared_error(test[i:len(test) - cfg['forecast_horizon'] + i],
pred_es[:, i]))
# Exponential Smoothing 80% PI
coverage_es_80.append(
compute_coverage(
upper_limits=conf_int_es_80[:, i, 1],
lower_limits=conf_int_es_80[:, i, 0],
actual_values=test.values[i:len(test) -
cfg['forecast_horizon'] + i]))
width_es_80.append(
np.mean(conf_int_es_80[:, i, 1] - conf_int_es_80[:, i, 0], axis=0))
# Exponential Smoothing 95% PI
coverage_es_95.append(
compute_coverage(
upper_limits=conf_int_es_95[:, i, 1],
lower_limits=conf_int_es_95[:, i, 0],
actual_values=test.values[i:len(test) -
cfg['forecast_horizon'] + i]))
width_es_95.append(
np.mean(conf_int_es_95[:, i, 1] - conf_int_es_95[:, i, 0], axis=0))
print('================ ARIMA =================')
print('Mean MSE', np.mean(mse_arima))
print('MSE sliding window', mse_arima)
print('Coverage of 80% PI sliding window', coverage_arima_80)
print('Width of 80% PI sliding window', width_arima_80)
print('Coverage of 95% PI sliding window', coverage_arima_95)
print('Width of 95% PI sliding window', width_arima_95)
print('================ ES ====================')
print('MSE sliding window', np.mean(mse_es))
print('Mean MSE', np.mean(mse_arima))
print('Coverage of 80% PI sliding window', coverage_es_80)
print('Width of 80% PI sliding window', width_es_80)
print('Coverage of 95% PI sliding window', coverage_es_95)
print('Width of 95% PI sliding window', width_es_95)
return mse_arima, coverage_arima_80, coverage_arima_95, width_arima_80, width_arima_95, coverage_es_80, mse_es, \
coverage_es_95, width_es_80, width_es_95
def arima(df, cfg):
# df = df.diff(periods=1).dropna()
# result = adfuller(df['y'].values)
# print('ADF Statistic: %f' % result[0])
# print('p-value: %f' % result[1])
train, test = train_test_split(df['y'], cfg['test_size'])
#auto_model = auto_arima(train, start_p=1, start_q=1, max_p=3, max_q=3,
# m=52, start_P=1, start_Q=1, seasonal=True, d=1, D=1, suppress_warnings=True,
# stepwise=True)
auto_model = auto_arima(train,
start_p=1,
start_q=1,
max_p=3,
max_q=3,
max_d=1,
max_P=1,
max_Q=1,
max_D=1,
m=52,
start_P=0,
start_Q=0,
seasonal=True,
d=None,
D=None,
suppress_warnings=True,
stepwise=True,
information_criterion='aicc')
print(auto_model.summary())
pred_arima = np.zeros(
[len(test) - cfg['forecast_horizon'], cfg['forecast_horizon']])
conf_int_arima_80 = np.zeros(
[len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
conf_int_arima_95 = np.zeros(
[len(test) - cfg['forecast_horizon'], cfg['forecast_horizon'], 2])
for i in range(len(test) - cfg['forecast_horizon']):
forecast_arima_95 = auto_model.predict(
n_periods=cfg['forecast_horizon'],
return_conf_int=True,
alpha=1 - 0.95)
forecast_arima_80 = auto_model.predict(
n_periods=cfg['forecast_horizon'],
return_conf_int=True,
alpha=1 - 0.8)
pred_arima[i] = forecast_arima_95[0]
conf_int_arima_80[i] = forecast_arima_80[1]
conf_int_arima_95[i] = forecast_arima_95[1]
auto_model.update(y=[test.values[i]])
# Store results
mse_arima, coverage_arima_95, coverage_arima_80, width_arima_95, width_arima_80 = [], [], [], [], []
for i in range(cfg['forecast_horizon']):
# ARIMA mean squared error (MSE):
mse_arima.append(
mean_squared_error(test[i:len(test) - cfg['forecast_horizon'] + i],
pred_arima[:, i]))
# ARIMA 80% PI
coverage_arima_80.append(
compute_coverage(
upper_limits=conf_int_arima_80[:, i, 1],
lower_limits=conf_int_arima_80[:, i, 0],
actual_values=test.values[i:len(test) -
cfg['forecast_horizon'] + i]))
width_arima_80.append(
np.mean(conf_int_arima_80[:, i, 1] - conf_int_arima_80[:, i, 0],
axis=0))
# ARIMA 95% PI
coverage_arima_95.append(
compute_coverage(
upper_limits=conf_int_arima_95[:, i, 1],
lower_limits=conf_int_arima_95[:, i, 0],
actual_values=test.values[i:len(test) -
cfg['forecast_horizon'] + i]))
width_arima_95.append(
np.mean(conf_int_arima_95[:, i, 1] - conf_int_arima_95[:, i, 0],
axis=0))
print('================ ARIMA =================')
print('Mean MSE', np.mean(mse_arima))
print('MSE sliding window', mse_arima)
print('Coverage of 80% PI sliding window', coverage_arima_80)
print('Width of 80% PI sliding window', width_arima_80)
print('Coverage of 95% PI sliding window', coverage_arima_95)
print('Width of 95% PI sliding window', width_arima_95)
return mse_arima, coverage_arima_80, coverage_arima_95, width_arima_80, width_arima_95