--- title: N-BEATS: Neural Basis Expansion Analysis keywords: fastai sidebar: home_sidebar summary: "API details." description: "API details." nb_path: "nbs/models_nbeats__nbeats.ipynb" ---
# from google.colab import drive
# drive.mount('/content/drive')
# os.chdir('./drive/MyDrive/nixtlats')
# print(os.getcwd())
# !pip install torchinfo
# !pip install fastcore
# !pip install s3fs
# !pip install patool
from torchinfo import summary
model = _NBEATS(n_time_in=168,
n_time_out=24,
n_s=1,
n_x=10,
n_s_hidden=100,
n_x_hidden=30,
n_polynomials=2,
n_harmonics=4,
stack_types=['trend', 'seasonality', 'exogenous_wavenet'],
n_blocks=[1, 1, 1],
n_layers=[2, 2, 2],
n_theta_hidden=3 * [[128, 128]],
dropout_prob_theta=0,
activation='SELU',
initialization='lecun_normal',
batch_normalization=True,
shared_weights=True)
# inputs: S, Y, X, insample_mask
# S.shape (n_batch,n_s)
# Y.shape (n_batch,n_time_in+n_time_out)
# X.shape (n_batch,n_x,n_time_in+n_time_out)
# insample_mask.shape (n_batch,n_time_in+n_time_out)
# summary(model, input_size=[(256, 1), (256, 168+24), (256, 10, 168+24), (256, 168+24)])
import multiprocessing
import pandas as pd
from nixtlats.data.datasets.epf import EPF#, EPFInfo
from nixtlats.data.tsloader import TimeSeriesLoader
import pylab as plt
from pylab import rcParams
plt.style.use('seaborn-whitegrid')
plt.rcParams['font.family'] = 'serif'
FONTSIZE = 19
# Load and plot data
Y_df, X_df, S_df = EPF.load_groups(directory='./data', groups=['NP'])
fig = plt.figure(figsize=(15, 6))
plt.plot(Y_df.ds, Y_df.y.values, color='#628793', linewidth=0.4)
plt.ylabel('Price [EUR/MWh]', fontsize=19)
plt.xlabel('Date', fontsize=15)
# plt.savefig('./results/NP.png', bbox_inches = 'tight')
plt.show()
mc = {}
mc['model'] = 'nbeats'
mc['mode'] = 'simple'
mc['activation'] = 'SELU'
mc['n_time_in'] = 24*7
mc['n_time_out'] = 24*7
mc['n_x_hidden'] = 8
mc['n_s_hidden'] = 0
# mc['input_size_multiplier'] = 7
# mc['output_size'] = 24
mc['stack_types'] = ['trend', 'seasonality', 'exogenous_wavenet']
mc['n_blocks'] = [1, 1, 1]
mc['n_layers'] = [2, 2, 2]
# mc['stack_types'] = ['trend', 'seasonality']
# mc['n_blocks'] = [1, 1]
# mc['n_layers'] = [2, 2]
mc['n_hidden'] = 128
mc['shared_weights'] = False
mc['n_harmonics'] = 4
mc['n_polynomials'] = 2
# Optimization and regularization parameters
mc['initialization'] = 'lecun_normal'
mc['learning_rate'] = 0.0007
mc['batch_size'] = 128
mc['lr_decay'] = 0.5
mc['lr_decay_step_size'] = 2
mc['max_epochs'] = 1#_000
mc['max_steps'] = 20#_000
mc['early_stop_patience'] = 20
mc['eval_freq'] = 500
mc['batch_normalization'] = False
mc['dropout_prob_theta'] = 0.51
mc['dropout_prob_exogenous'] = 0.44
mc['l1_theta'] = 0
mc['weight_decay'] = 0
mc['loss_train'] = 'MAE'
mc['loss_hypar'] = 0.5
mc['loss_valid'] = mc['loss_train']
mc['random_seed'] = 1
# Data Parameters
mc['len_sample_chunks'] = None
mc['idx_to_sample_freq'] = 1
mc['val_idx_to_sample_freq'] = 24 * 7
mc['n_val_weeks'] = 52
mc['window_sampling_limit'] = 500_000
mc['normalizer_y'] = None
mc['normalizer_x'] = 'median'
mc['complete_inputs'] = False
mc['frequency'] = 'H'
mc['seasonality'] = 24
# # Within decomposition
mc['learning_rate'] = 0.0005
mc['batch_size'] = 256
mc['weight_decay'] = 0.00006
mc['n_harmonics'] = 2
mc['n_polynomials'] = 4
mc['dropout_prob_theta'] = 0
mc['dropout_prob_exogenous'] = 0
print(65*'=')
print(pd.Series(mc))
print(65*'=')
mc['n_theta_hidden'] = len(mc['stack_types']) * [ [int(mc['n_hidden']), int(mc['n_hidden'])] ]
from nixtlats.experiments.utils import create_datasets
train_dataset, val_dataset, test_dataset, scaler_y = create_datasets(mc=mc,
S_df=S_df, Y_df=Y_df, X_df=X_df,
f_cols=['Exogenous1', 'Exogenous2'],
ds_in_val=294*24,
ds_in_test=728*24,
n_uids=None, n_val_windows=None,freq=None,
is_val_random=False)
train_loader = TimeSeriesLoader(dataset=train_dataset,
batch_size=int(mc['batch_size']),
#num_workers=int(min(multiprocessing.cpu_count(), 3)),
shuffle=True)
val_loader = TimeSeriesLoader(dataset=val_dataset,
batch_size=int(mc['batch_size']),
#num_workers=int(min(multiprocessing.cpu_count(), 3)),
shuffle=False)
test_loader = TimeSeriesLoader(dataset=test_dataset,
batch_size=int(mc['batch_size']),
#num_workers=int(min(multiprocessing.cpu_count(), 3)),
shuffle=False)
mc['n_x'], mc['n_s'] = train_dataset.get_n_variables()
model = NBEATS(n_time_in=int(mc['n_time_in']),
n_time_out=int(mc['n_time_out']),
n_x=mc['n_x'],
n_s=mc['n_s'],
n_s_hidden=int(mc['n_s_hidden']),
n_x_hidden=int(mc['n_x_hidden']),
shared_weights=mc['shared_weights'],
initialization=mc['initialization'],
activation=mc['activation'],
stack_types=mc['stack_types'],
n_blocks=mc['n_blocks'],
n_layers=mc['n_layers'],
n_theta_hidden=mc['n_theta_hidden'],
n_harmonics=int(mc['n_harmonics']),
n_polynomials=int(mc['n_polynomials']),
batch_normalization = mc['batch_normalization'],
dropout_prob_theta=mc['dropout_prob_theta'],
learning_rate=float(mc['learning_rate']),
lr_decay=float(mc['lr_decay']),
lr_decay_step_size=float(mc['lr_decay_step_size']),
weight_decay=mc['weight_decay'],
loss_train=mc['loss_train'],
loss_hypar=float(mc['loss_hypar']),
loss_valid=mc['loss_valid'],
frequency=mc['frequency'],
seasonality=int(mc['seasonality']),
random_seed=int(mc['random_seed']))
from pytorch_lightning.callbacks import EarlyStopping
early_stopping = EarlyStopping(monitor="val_loss",
min_delta=1e-4,
patience=mc['early_stop_patience'],
verbose=False,
mode="min")
trainer = pl.Trainer(max_epochs=mc['max_epochs'],
max_steps=mc['max_steps'],
gradient_clip_val=1.0,
progress_bar_refresh_rate=10,
log_every_n_steps=500,
check_val_every_n_epoch=1,
callbacks=[early_stopping])
trainer.fit(model, train_loader, val_loader)
model.return_decomposition = True
outputs = trainer.predict(model, val_loader)
print("outputs[0][0].shape", outputs[0][0].shape)
print("outputs[0][1].shape", outputs[0][1].shape)
print("outputs[0][2].shape", outputs[0][2].shape)