def lstm_dense_sunspots(args):
"""
Main function
"""
# %%
# IMPORTS
# code repository sub-package imports
from artificial_neural_networks.utils.download_monthly_sunspots import \
download_monthly_sunspots
from artificial_neural_networks.utils.generic_utils import save_regress_model, \
series_to_supervised, affine_transformation
from artificial_neural_networks.utils.vis_utils import regression_figs
# %%
if args.verbose > 0:
print(args)
# For reproducibility
if args.reproducible:
os.environ['PYTHONHASHSEED'] = '0'
np.random.seed(args.seed)
rn.seed(args.seed)
tf.set_random_seed(args.seed)
sess = tf.Session(graph=tf.get_default_graph())
K.set_session(sess)
# print(hash("keras"))
# %%
# Load the Monthly sunspots dataset
sunspots_path = download_monthly_sunspots()
sunspots = np.genfromtxt(fname=sunspots_path,
dtype=np.float32,
delimiter=",",
skip_header=1,
usecols=1)
# %%
# Train-Test split
L_series = len(sunspots)
split_ratio = 2 / 3 # between zero and one
n_split = int(L_series * split_ratio)
look_back = args.look_back
steps_ahead = args.steps_ahead
train = sunspots[:n_split + (steps_ahead - 1)]
test = sunspots[n_split - look_back:]
train_x, train_y = series_to_supervised(train, look_back, steps_ahead)
test_x, test_y = series_to_supervised(test, look_back, steps_ahead)
train_y_series = train[look_back:train.shape[0] - (steps_ahead - 1)]
test_y_series = test[look_back:]
# %%
# PREPROCESSING STEP
scaling_factor = args.scaling_factor
translation = args.translation
n_train = train_x.shape[0] # number of training examples/samples
n_test = test_x.shape[0] # number of test examples/samples
n_in = train_x.shape[1] # number of features / dimensions
n_out = train_y.shape[1] # number of steps ahead to be predicted
# Reshape training and test sets
train_x = train_x.reshape(n_train, n_in, 1)
test_x = test_x.reshape(n_test, n_in, 1)
# Apply preprocessing
train_x_ = affine_transformation(train_x, scaling_factor, translation)
train_y_ = affine_transformation(train_y, scaling_factor, translation)
test_x_ = affine_transformation(test_x, scaling_factor, translation)
test_y_ = affine_transformation(test_y, scaling_factor, translation)
train_y_series_ = affine_transformation(train_y_series, scaling_factor,
translation)
test_y_series_ = affine_transformation(test_y_series, scaling_factor,
translation)
# %%
# Model hyperparameters and ANN Architecture
stateful = args.stateful
if stateful:
x = Input(shape=(n_in, 1), batch_shape=(1, n_in, 1)) # input layer
else:
x = Input(shape=(n_in, 1)) # input layer
h = x
h = LSTM(units=args.layer_size, stateful=stateful)(h) # hidden layer
out = Dense(units=n_out, activation=None)(h) # output layer
model = Model(inputs=x, outputs=out)
if args.verbose > 0:
model.summary()
def root_mean_squared_error(y_true, y_pred):
return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
loss_function = root_mean_squared_error
metrics = ['mean_absolute_error', 'mean_absolute_percentage_error']
lr = args.lrearning_rate
epsilon = args.epsilon
optimizer_selection = {
'Adadelta':
optimizers.Adadelta(lr=lr, rho=0.95, epsilon=epsilon, decay=0.0),
'Adagrad':
optimizers.Adagrad(lr=lr, epsilon=epsilon, decay=0.0),
'Adam':
optimizers.Adam(lr=lr,
beta_1=0.9,
beta_2=0.999,
epsilon=epsilon,
decay=0.0,
amsgrad=False),
'Adamax':
optimizers.Adamax(lr=lr,
beta_1=0.9,
beta_2=0.999,
epsilon=epsilon,
decay=0.0),
'Nadam':
optimizers.Nadam(lr=lr,
beta_1=0.9,
beta_2=0.999,
epsilon=epsilon,
schedule_decay=0.004),
'RMSprop':
optimizers.RMSprop(lr=lr, rho=0.9, epsilon=epsilon, decay=0.0),
'SGD':
optimizers.SGD(lr=lr, momentum=0.0, decay=0.0, nesterov=False)
}
optimizer = optimizer_selection[args.optimizer]
model.compile(optimizer=optimizer, loss=loss_function, metrics=metrics)
# %%
# Save trained models for every epoch
models_path = r'artificial_neural_networks/trained_models/'
model_name = 'sunspots_lstm_dense'
weights_path = models_path + model_name + '_weights'
model_path = models_path + model_name + '_model'
file_suffix = '_{epoch:04d}_{val_loss:.4f}_{val_mean_absolute_error:.4f}'
if args.save_weights_only:
file_path = weights_path
else:
file_path = model_path
file_path += file_suffix
monitor = 'val_loss'
if args.save_models:
checkpoint = ModelCheckpoint(file_path + '.h5',
monitor=monitor,
verbose=args.verbose,
save_best_only=args.save_best,
mode='auto',
save_weights_only=args.save_weights_only)
callbacks = [checkpoint]
else:
callbacks = []
# %%
# TRAINING PHASE
"""
if stateful:
shuffle = False
else:
shuffle = True
"""
if args.time_training:
start = timer()
for i in range(0, args.n_epochs):
if args.verbose > 0:
print('Epoch: {0}/{1}'.format(i + 1, args.n_epochs))
model.fit(x=train_x_,
y=train_y_,
validation_data=(test_x_, test_y_),
batch_size=args.batch_size,
epochs=1,
verbose=args.verbose,
callbacks=callbacks,
shuffle=True)
if stateful:
model.reset_states()
if args.time_training:
end = timer()
duration = end - start
print('Total time for training (in seconds):')
print(duration)
# %%
def model_predict(x_, y_):
"""
Predict using the LSTM Model (Multi-step ahead Forecasting)
"""
n_y_ = y_.shape[0]
y_pred = np.zeros(n_y_)
if args.recursive: # Recursive Strategy
if args.verbose > 0:
print('Following Recursive Strategy ...')
n_x_ = x_.shape[0]
n_iter = int(np.floor(n_x_ / steps_ahead))
L_last_window = n_x_ % steps_ahead
first = 0
# Multi-step ahead Forecasting of all the full windows
for i in range(0, n_iter):
""" if args.verbose > 0:
print('Completed: {0}/{1}'.format(i + 1, n_iter + 1)) """
pred_start = i * steps_ahead
pred_end = pred_start + steps_ahead
# first time step of each window (no recursion possible)
j = pred_start
k = j - pred_start # (always zero and unused)
x_dyn = np.copy(x_[j:j + 1]) # use actual values only
y_dyn = model.predict(x_dyn)[:, first]
y_pred[j:j + 1] = y_dyn
# remaining time steps of each window (with recursion)
for j in range(pred_start + 1, pred_end):
k = j - pred_start
x_dyn = np.copy(x_[j:j +
1]) # use actual values (if possible)
x_start = np.max([0, look_back - k])
y_start = np.max([0, k - look_back]) + pred_start
# y_start = np.max([pred_start, j - look_back])
x_dyn[0, x_start:look_back,
0] = np.copy(y_pred[y_start:j]) # use pred. values
y_dyn = model.predict(x_dyn)[:, first]
# y_after = np.max([0, y_dyn]) + 0.015 * np.random.randn()
y_pred[j:j + 1] = np.max([0, y_dyn])
# y_pred[j:j + 1] = y_dyn
# Multi-step ahead Forecasting of the last window
if L_last_window > 0:
""" if args.verbose > 0:
print('Completed: {0}/{1}'.format(n_iter + 1, n_iter + 1)) """
pred_start = n_x_ - L_last_window
pred_end = n_y_
# first time step of the last window (no recursion possible)
j = pred_start
k = j - pred_start # (always zero and unused)
x_dyn = np.copy(x_[j:j + 1]) # use actual values only
y_dyn = model.predict(x_dyn)[:, first]
y_pred[j:j + 1] = y_dyn
# remaining time steps of the last window (with recursion)
for j in range(pred_start + 1, pred_end):
k = j - pred_start
x_dyn = np.roll(x_dyn, -1) # use act. values (if possible)
x_start = np.max([0, look_back - k])
y_start = np.max([0, k - look_back]) + pred_start
# y_start = np.max([pred_start, j - look_back])
x_dyn[0, x_start:look_back,
0] = np.copy(y_pred[y_start:j]) # use pred. values
y_dyn = model.predict(x_dyn)[:, first]
# y_after = np.max([0, y_dyn]) + 0.015 * np.random.randn()
y_pred[j:j + 1] = np.max([0, y_dyn])
# y_pred[j:j + 1] = y_dyn
"""
# One-step ahead Forecasting
n_x_ = x_.shape[0]
for i in range(0, n_x_):
x_dyn = x_[i:i+1]
y_dyn = model.predict(x_dyn)[0, 0]
y_pred[i] = y_dyn
for i in range(n_x_, n_y):
x_dyn[0, :, 0] = y_[i - look_back:i]
y_dyn = model.predict(x_dyn)[0, 0]
y_pred[i] = y_dyn
"""
else: # Multiple Ouptput Strategy
if args.verbose > 0:
print('Following Multiple Ouptput Strategy ...')
n_iter = int(np.floor(n_y_ / steps_ahead))
L_last_window = n_y_ % steps_ahead
# Multi-step ahead Forecasting of all the full windows
for i in range(0, n_iter):
pred_start = i * steps_ahead
pred_end = pred_start + steps_ahead
x_dyn = x_[pred_start:pred_start + 1]
y_dyn = model.predict(x_dyn)[0]
y_pred[pred_start:pred_end] = y_dyn
# Multi-step ahead Forecasting of the last window
if L_last_window > 0:
pred_start = n_y_ - L_last_window
pred_end = n_y_
x_dyn[0, :, 0] = y_[pred_end - look_back:pred_end]
y_dyn = model.predict(x_dyn)[0]
y_pred[pred_start:pred_end] = y_dyn[:L_last_window]
return y_pred
# %%
# TESTING PHASE
# Predict preprocessed values
train_y_sum = [0]
test_y_sum = [0]
reps = 1
for i in range(reps):
train_y_pred_ = model_predict(train_x_, train_y_series_)
test_y_pred_ = model_predict(test_x_, test_y_series_)
train_y_sum = np.sum([train_y_sum, train_y_pred_], axis=0)
test_y_sum = np.sum([test_y_sum, test_y_pred_], axis=0)
train_y_pred_ = train_y_sum / reps
test_y_pred_ = test_y_sum / reps
# Remove preprocessing
train_y_pred = affine_transformation(train_y_pred_,
scaling_factor,
translation,
inverse=True)
test_y_pred = affine_transformation(test_y_pred_,
scaling_factor,
translation,
inverse=True)
train_rmse = sqrt(mean_squared_error(train_y_series, train_y_pred))
train_mae = mean_absolute_error(train_y_series, train_y_pred)
train_r2 = r2_score(train_y_series, train_y_pred)
test_rmse = sqrt(mean_squared_error(test_y_series, test_y_pred))
test_mae = mean_absolute_error(test_y_series, test_y_pred)
test_r2 = r2_score(test_y_series, test_y_pred)
if args.verbose > 0:
print('Train RMSE: %.4f ' % (train_rmse))
print('Train MAE: %.4f ' % (train_mae))
print('Train (1 - R_squared): %.4f ' % (1.0 - train_r2))
print('Train R_squared: %.4f ' % (train_r2))
print('')
print('Test RMSE: %.4f ' % (test_rmse))
print('Test MAE: %.4f ' % (test_mae))
print('Test (1 - R_squared): %.4f ' % (1.0 - test_r2))
print('Test R_squared: %.4f ' % (test_r2))
# %%
# Data Visualization
if args.plot:
regression_figs(train_y=train_y_series,
train_y_pred=train_y_pred,
test_y=test_y_series,
test_y_pred=test_y_pred)
# %%
# Save the architecture and the lastly trained model
save_regress_model(model, models_path, model_name, weights_path,
model_path, file_suffix, test_rmse, test_mae, args)
# %%
return model
def sarimax_sunspots(args):
"""
Main function
"""
# %%
# IMPORTS
# code repository sub-package imports
from artificial_neural_networks.utils.download_monthly_sunspots import \
download_monthly_sunspots
from artificial_neural_networks.utils.generic_utils import affine_transformation
from artificial_neural_networks.utils.vis_utils import regression_figs
# %%
if args.verbose > 0:
print(args)
# For reproducibility
if args.reproducible:
os.environ['PYTHONHASHSEED'] = '0'
np.random.seed(args.seed)
rn.seed(args.seed)
# %%
# Load the Monthly sunspots dataset
sunspots_path = download_monthly_sunspots()
sunspots = np.genfromtxt(fname=sunspots_path,
dtype=np.float32,
delimiter=",",
skip_header=1,
usecols=1)
# %%
# Train-Test split
L_series = len(sunspots)
split_ratio = 2 / 3 # between zero and one
n_split = int(L_series * split_ratio)
steps_ahead = args.steps_ahead
train_y = sunspots[:n_split]
test_y = sunspots[n_split:]
# %%
# PREPROCESSING STEP
scaling_factor = args.scaling_factor
translation = args.translation
n_train = train_y.shape[0] # number of training examples/samples
# Apply preprocessing
train_y_ = affine_transformation(train_y, scaling_factor, translation)
test_y_ = affine_transformation(test_y, scaling_factor, translation)
# %%
# Model hyperparameters
optimizer = 'lbfgs'
# optimizer = 'powell'
maxiter = 1
# maxiter = 50
s = args.seasonal_periods
order = (args.autoregressive, args.integrated, args.moving_average)
seasonal_order = (0, 1, 0, s)
trend = 'ct'
# %%
# TRAINING PHASE
if args.use_custom_params:
custom_params = np.zeros(6)
custom_params[0] = 0.6446147426983434 # 0.4446147426983434
custom_params[1] = -0.00067190913463951184 # -0.00047190913463951184
custom_params[2] = 0.0 # 0.0
custom_params[3] = 0.9518981714555636 # 0.9418981714555636
custom_params[4] = -0.38742006217597214 # -0.38742006217597214
custom_params[5] = 460.2075087762523 # 460.2075087762523
if args.verbose > 0:
print('All parameters:')
print(custom_params)
fitted_params = custom_params
else:
train_outliers = np.zeros(n_train)
train_model = SARIMAX(train_y_,
order=order,
seasonal_order=seasonal_order,
exog=train_outliers,
trend=trend)
fitted_params = None
if args.time_training:
start = timer()
for i in range(1):
model_fit = train_model.fit(start_params=fitted_params,
method=optimizer,
maxiter=maxiter)
fitted_params = model_fit.params
if args.verbose > 0:
print('All parameters:')
print(fitted_params)
if args.time_training:
end = timer()
duration = end - start
print('Total time for training (in seconds):')
print(duration)
if args.verbose > 0:
print(model_fit.summary())
def model_predict(y):
"""
Predict using the SARIMAX Model (Multi-step ahead Forecasting)
"""
n_y = y.shape[0]
y_pred = np.zeros(n_y)
n_iter = int(np.floor(n_y / steps_ahead))
L_last_window = n_y % steps_ahead
# Multi-step ahead Forecasting of all the full windows
window_start = steps_ahead
window_end = window_start + steps_ahead - 1
for i in range(1, n_iter):
pred_start = i * steps_ahead
pred_end = pred_start + steps_ahead - 1
pred_outliers = np.zeros((steps_ahead, 1))
x = y[pred_start - steps_ahead:pred_start]
pred_model = SARIMAX(x,
order=order,
seasonal_order=seasonal_order,
exog=pred_outliers,
trend=trend)
y_pred[pred_start:pred_end +
1] = pred_model.filter(fitted_params).get_prediction(
start=window_start, end=window_end,
exog=pred_outliers).predicted_mean
if L_last_window > 0:
# Multi-step ahead Forecasting of the last window
window_start = steps_ahead
window_end = window_start + L_last_window - 1
pred_start = n_y - L_last_window
pred_end = n_y
pred_outliers = np.zeros((steps_ahead, 1))
x = y[pred_start - steps_ahead:pred_start]
pred_model = SARIMAX(x,
order=order,
seasonal_order=seasonal_order,
exog=pred_outliers,
trend=trend)
pred_outliers = np.zeros((L_last_window, 1))
y_pred[pred_start:pred_end +
1] = pred_model.filter(fitted_params).get_prediction(
start=window_start, end=window_end,
exog=pred_outliers).predicted_mean
return y_pred
# %%
# TESTING PHASE
# Predict preprocessed values
train_y_pred_ = model_predict(train_y_)
test_y_pred_ = model_predict(test_y_)
# Remove preprocessing
train_y_pred = affine_transformation(train_y_pred_,
scaling_factor,
translation,
inverse=True)
test_y_pred = affine_transformation(test_y_pred_,
scaling_factor,
translation,
inverse=True)
train_y_pred[:s] = np.zeros(s)
test_y_pred[:s] = np.zeros(s)
train_rmse = sqrt(mean_squared_error(train_y, train_y_pred))
train_mae = mean_absolute_error(train_y, train_y_pred)
train_r2 = r2_score(train_y, train_y_pred)
test_rmse = sqrt(mean_squared_error(test_y, test_y_pred))
test_mae = mean_absolute_error(test_y, test_y_pred)
test_r2 = r2_score(test_y, test_y_pred)
if args.verbose > 0:
print('Train RMSE: %.4f ' % (train_rmse))
print('Train MAE: %.4f ' % (train_mae))
print('Train (1 - R_squared): %.4f ' % (1.0 - train_r2))
print('Train R_squared: %.4f ' % (train_r2))
print('')
print('Test RMSE: %.4f ' % (test_rmse))
print('Test MAE: %.4f ' % (test_mae))
print('Test (1 - R_squared): %.4f ' % (1.0 - test_r2))
print('Test R_squared: %.4f ' % (test_r2))
# %%
# Data Visualization
if args.plot:
regression_figs(train_y=train_y,
train_y_pred=train_y_pred,
test_y=test_y,
test_y_pred=test_y_pred)
# %%
model = {}
model['params'] = fitted_params
model['hyperparams'] = {}
model['hyperparams']['order'] = order
model['hyperparams']['seasonal_order'] = seasonal_order
model['hyperparams']['trend'] = trend
return model
def lstm_dense_sunspots(args):
"""
Main function
"""
# %%
# IMPORTS
# code repository sub-package imports
from artificial_neural_networks.utils.download_monthly_sunspots import \
download_monthly_sunspots
from artificial_neural_networks.utils.generic_utils import save_regress_model, \
series_to_supervised, affine_transformation
from artificial_neural_networks.utils.vis_utils import regression_figs
# %%
if args.verbose > 0:
print(args)
# For reproducibility
if args.reproducible:
os.environ['PYTHONHASHSEED'] = '0'
np.random.seed(args.seed)
rn.seed(args.seed)
tf.set_random_seed(args.seed)
sess = tf.Session(graph=tf.get_default_graph())
K.set_session(sess)
# print(hash("keras"))
# %%
# Load the Monthly sunspots dataset
sunspots_path = download_monthly_sunspots()
sunspots = np.genfromtxt(
fname=sunspots_path, dtype=np.float32, delimiter=",", skip_header=1, usecols=1)
# %%
# Train-Test split
L_series = len(sunspots)
split_ratio = 2 / 3 # between zero and one
n_split = int(L_series * split_ratio)
look_back = args.look_back
train = sunspots[:n_split]
test = sunspots[n_split - look_back:]
train_x, train_y = series_to_supervised(train, look_back)
test_x, test_y = series_to_supervised(test, look_back)
# %%
# PREPROCESSING STEP
scaling_factor = args.scaling_factor
translation = args.translation
n_train = train_x.shape[0] # number of training examples/samples
n_test = test_x.shape[0] # number of test examples/samples
n_in = train_x.shape[1] # number of features / dimensions
n_out = train_y.shape[1] # number of steps ahead to be predicted
# Reshape training and test sets
train_x = train_x.reshape(n_train, n_in, 1)
test_x = test_x.reshape(n_test, n_in, 1)
# Apply preprocessing
train_x_ = affine_transformation(train_x, scaling_factor, translation)
train_y_ = affine_transformation(train_y, scaling_factor, translation)
test_x_ = affine_transformation(test_x, scaling_factor, translation)
test_y_ = affine_transformation(test_y, scaling_factor, translation)
# %%
# Model hyperparameters and ANN Architecture
x = Input(shape=(n_in, 1)) # input layer
h = x
h = LSTM(units=args.layer_size)(h) # hidden layer
out = Dense(units=n_out, activation=None)(h) # output layer
model = Model(inputs=x, outputs=out)
if args.verbose > 0:
model.summary()
def root_mean_squared_error(y_true, y_pred):
return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
loss_function = root_mean_squared_error
metrics = ['mean_absolute_error', 'mean_absolute_percentage_error']
lr = args.lrearning_rate
epsilon = args.epsilon
optimizer_selection = {
'Adadelta':
optimizers.Adadelta(lr=lr, rho=0.95, epsilon=epsilon, decay=0.0),
'Adagrad':
optimizers.Adagrad(lr=lr, epsilon=epsilon, decay=0.0),
'Adam':
optimizers.Adam(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=epsilon, decay=0.0, amsgrad=False),
'Adamax':
optimizers.Adamax(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=epsilon, decay=0.0),
'Nadam':
optimizers.Nadam(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=epsilon, schedule_decay=0.004),
'RMSprop':
optimizers.RMSprop(lr=lr, rho=0.9, epsilon=epsilon, decay=0.0),
'SGD':
optimizers.SGD(lr=lr, momentum=0.0, decay=0.0, nesterov=False)
}
optimizer = optimizer_selection[args.optimizer]
model.compile(optimizer=optimizer, loss=loss_function, metrics=metrics)
# %%
# Save trained models for every epoch
models_path = r'artificial_neural_networks/trained_models/'
model_name = 'sunspots_lstm_dense'
weights_path = models_path + model_name + '_weights'
model_path = models_path + model_name + '_model'
file_suffix = '_{epoch:04d}_{val_loss:.4f}_{val_mean_absolute_error:.4f}'
if args.save_weights_only:
file_path = weights_path
else:
file_path = model_path
file_path += file_suffix
monitor = 'val_loss'
if args.save_models:
checkpoint = ModelCheckpoint(
file_path + '.h5',
monitor=monitor,
verbose=args.verbose,
save_best_only=args.save_best,
mode='auto',
save_weights_only=args.save_weights_only)
callbacks = [checkpoint]
else:
callbacks = []
# %%
# TRAINING PHASE
if args.time_training:
start = timer()
model.fit(
x=train_x_,
y=train_y_,
validation_data=(test_x_, test_y_),
batch_size=args.batch_size,
epochs=args.n_epochs,
verbose=args.verbose,
callbacks=callbacks)
if args.time_training:
end = timer()
duration = end - start
print('Total time for training (in seconds):')
print(duration)
# %%
# TESTING PHASE
# Predict preprocessed values
train_y_pred_ = model.predict(train_x_)[:, 0]
test_y_pred_ = model.predict(test_x_)[:, 0]
# Remove preprocessing
train_y_pred = affine_transformation(train_y_pred_, scaling_factor, translation, inverse=True)
test_y_pred = affine_transformation(test_y_pred_, scaling_factor, translation, inverse=True)
train_rmse = sqrt(mean_squared_error(train_y, train_y_pred))
train_mae = mean_absolute_error(train_y, train_y_pred)
train_r2 = r2_score(train_y, train_y_pred)
test_rmse = sqrt(mean_squared_error(test_y, test_y_pred))
test_mae = mean_absolute_error(test_y, test_y_pred)
test_r2 = r2_score(test_y, test_y_pred)
if args.verbose > 0:
print('Train RMSE: %.4f ' % (train_rmse))
print('Train MAE: %.4f ' % (train_mae))
print('Train (1 - R_squared): %.4f ' % (1.0 - train_r2))
print('Train R_squared: %.4f ' % (train_r2))
print('')
print('Test RMSE: %.4f ' % (test_rmse))
print('Test MAE: %.4f ' % (test_mae))
print('Test (1 - R_squared): %.4f ' % (1.0 - test_r2))
print('Test R_squared: %.4f ' % (test_r2))
# %%
# Data Visualization
if args.plot:
regression_figs(train_y=train_y, train_y_pred=train_y_pred,
test_y=test_y, test_y_pred=test_y_pred)
# %%
# Save the architecture and the lastly trained model
save_regress_model(model, models_path, model_name, weights_path, model_path, file_suffix,
test_rmse, test_mae, args)
# %%
return model
def sarimax_sunspots(args):
"""
Main function
"""
# %%
# IMPORTS
# code repository sub-package imports
from artificial_neural_networks.utils.download_monthly_sunspots import \
download_monthly_sunspots
from artificial_neural_networks.utils.generic_utils import affine_transformation
from artificial_neural_networks.utils.vis_utils import regression_figs
# %%
if args.verbose > 0:
print(args)
# For reproducibility
if args.reproducible:
os.environ['PYTHONHASHSEED'] = '0'
np.random.seed(args.seed)
rn.seed(args.seed)
# %%
# Load the Monthly sunspots dataset
sunspots_path = download_monthly_sunspots()
sunspots = np.genfromtxt(fname=sunspots_path,
dtype=np.float32,
delimiter=",",
skip_header=1,
usecols=1)
# %%
# Train-Test split
L_series = len(sunspots)
split_ratio = 2 / 3 # between zero and one
n_split = int(L_series * split_ratio)
train_y = sunspots[:n_split]
test_y = sunspots[n_split:]
# %%
# PREPROCESSING STEP
scaling_factor = args.scaling_factor
translation = args.translation
n_train = train_y.shape[0] # number of training examples/samples
# Apply preprocessing
train_y_ = affine_transformation(train_y, scaling_factor, translation)
test_y_ = affine_transformation(test_y, scaling_factor, translation)
# %%
# Model hyperparameters
optimizer = 'lbfgs'
# optimizer = 'powell'
maxiter = 15
# maxiter = 50
order = (args.autoregressive, args.integrated, args.moving_average)
seasonal_order = (0, 0, 0, 0)
trend = 'ct'
# %%
# TRAINING PHASE
train_outliers = np.zeros(n_train)
train_model = SARIMAX(train_y_,
order=order,
seasonal_order=seasonal_order,
exog=train_outliers,
trend=trend)
if args.time_training:
start = timer()
fitted_params = None
for i in range(1):
model_fit = train_model.fit(start_params=fitted_params,
method=optimizer,
maxiter=maxiter)
fitted_params = model_fit.params
if args.verbose > 0:
print('All parameters:')
print(fitted_params)
if args.time_training:
end = timer()
duration = end - start
print('Total time for training (in seconds):')
print(duration)
if args.verbose > 0:
print(model_fit.summary())
def model_predict(y):
"""
Predict using the SARIMAX Model (One-step ahead Forecasting)
"""
n_y = y.shape[0]
pred_outliers = np.zeros(n_y)
pred_model = SARIMAX(y,
order=order,
seasonal_order=seasonal_order,
exog=pred_outliers,
trend=trend)
y_pred = pred_model.filter(
fitted_params).get_prediction().predicted_mean
return y_pred
# %%
# TESTING PHASE
# Predict preprocessed values
train_y_pred_ = model_predict(train_y_)
test_y_pred_ = model_predict(test_y_)
# Remove preprocessing
train_y_pred = affine_transformation(train_y_pred_,
scaling_factor,
translation,
inverse=True)
test_y_pred = affine_transformation(test_y_pred_,
scaling_factor,
translation,
inverse=True)
train_rmse = sqrt(mean_squared_error(train_y, train_y_pred))
train_mae = mean_absolute_error(train_y, train_y_pred)
train_r2 = r2_score(train_y, train_y_pred)
test_rmse = sqrt(mean_squared_error(test_y, test_y_pred))
test_mae = mean_absolute_error(test_y, test_y_pred)
test_r2 = r2_score(test_y, test_y_pred)
if args.verbose > 0:
print('Train RMSE: %.4f ' % (train_rmse))
print('Train MAE: %.4f ' % (train_mae))
print('Train (1 - R_squared): %.4f ' % (1.0 - train_r2))
print('Train R_squared: %.4f ' % (train_r2))
print('')
print('Test RMSE: %.4f ' % (test_rmse))
print('Test MAE: %.4f ' % (test_mae))
print('Test (1 - R_squared): %.4f ' % (1.0 - test_r2))
print('Test R_squared: %.4f ' % (test_r2))
# %%
# Data Visualization
if args.plot:
regression_figs(train_y=train_y,
train_y_pred=train_y_pred,
test_y=test_y,
test_y_pred=test_y_pred)
# %%
model = {}
model['params'] = fitted_params
model['hyperparams'] = {}
model['hyperparams']['order'] = order
model['hyperparams']['seasonal_order'] = seasonal_order
model['hyperparams']['trend'] = trend
return model
def naive_persistence_model_sunspots(args):
"""
Main function
"""
# %%
# IMPORTS
# code repository sub-package imports
from artificial_neural_networks.utils.download_monthly_sunspots import \
download_monthly_sunspots
from artificial_neural_networks.utils.generic_utils import series_to_supervised, \
affine_transformation
from artificial_neural_networks.utils.vis_utils import regression_figs
# %%
if args.verbose > 0:
print(args)
# For reproducibility
if args.reproducible:
os.environ['PYTHONHASHSEED'] = '0'
np.random.seed(args.seed)
rn.seed(args.seed)
# %%
# Load the Monthly sunspots dataset
sunspots_path = download_monthly_sunspots()
sunspots = np.genfromtxt(fname=sunspots_path,
dtype=np.float32,
delimiter=",",
skip_header=1,
usecols=1)
# %%
# Train-Test split
L_series = len(sunspots)
split_ratio = 2 / 3 # between zero and one
n_split = int(L_series * split_ratio)
look_back = args.look_back
train = np.concatenate((np.zeros(look_back), sunspots[:n_split]))
test = sunspots[n_split - look_back:]
train_x, train_y = series_to_supervised(train, look_back)
test_x, test_y = series_to_supervised(test, look_back)
# %%
# PREPROCESSING STEP
scaling_factor = args.scaling_factor
translation = args.translation
# Apply preprocessing
train_x_ = affine_transformation(train_x, scaling_factor, translation)
test_x_ = affine_transformation(test_x, scaling_factor, translation)
# %%
# TRAINING PHASE
def model_predict(x):
"""
Predict using the Naive Persistence Model
"""
last = x.shape[1] - 1
y_pred = []
y_pred.append(x[0][last])
for i in range(x.shape[0] - 1):
y_pred.append(x[i][last])
return np.array(y_pred)
# %%
# TESTING PHASE
# Predict preprocessed values
train_y_pred_ = model_predict(train_x_)
test_y_pred_ = model_predict(test_x_)
# Remove preprocessing
train_y_pred = affine_transformation(train_y_pred_,
scaling_factor,
translation,
inverse=True)
test_y_pred = affine_transformation(test_y_pred_,
scaling_factor,
translation,
inverse=True)
train_rmse = sqrt(mean_squared_error(train_y, train_y_pred))
train_mae = mean_absolute_error(train_y, train_y_pred)
train_r2 = r2_score(train_y, train_y_pred)
test_rmse = sqrt(mean_squared_error(test_y, test_y_pred))
test_mae = mean_absolute_error(test_y, test_y_pred)
test_r2 = r2_score(test_y, test_y_pred)
if args.verbose > 0:
print('Train RMSE: %.4f ' % (train_rmse))
print('Train MAE: %.4f ' % (train_mae))
print('Train (1 - R_squared): %.4f ' % (1.0 - train_r2))
print('Train R_squared: %.4f ' % (train_r2))
print('')
print('Test RMSE: %.4f ' % (test_rmse))
print('Test MAE: %.4f ' % (test_mae))
print('Test (1 - R_squared): %.4f ' % (1.0 - test_r2))
print('Test R_squared: %.4f ' % (test_r2))
# %%
# Data Visualization
if args.plot:
regression_figs(train_y=train_y,
train_y_pred=train_y_pred,
test_y=test_y,
test_y_pred=test_y_pred)