def run_ESRNN():
import torch
device = 'cuda' if torch.cuda.is_available() else 'cpu'
path_daily = r'C:\Users\xxxli\Desktop\Daily'
dic_daily = preprocess.read_file(path_daily)
series_list = []
for k, v in dic_daily.items():
ticker_name = k
df, cat = v
df = preprocess.single_price(df, ticker_name) # column = [ticker]
series_list.append(DataSeries(cat, 'daily', df))
collect = DataCollection('universe daily', series_list)
train_dc, test_dc = collect.split(numTest = 24)
m = ModelESRNN( max_epochs = 15,
batch_size = 32, dilations=[[1,3], [7, 14]],
input_size = 12, output_size = 24,
device = device)
m.train(train_dc)
y_test = m.predict(test_dc)
y_test_df = y_test.to_df()
y_test_df.to_csv('hyper_ESRNN_1.csv')
def test_MP_class(self):
import torch
device = 'cuda' if torch.cuda.is_available() else 'cpu'
path_monthly = os.path.join('test','Data','Monthly')
dic_monthly = DP.read_file(path_monthly)
n_assets = 1
time_series_group = []
for i in range(n_assets):
df = dic_monthly[list(dic_monthly.keys())[i]]
ds = DataSeries('ETF', 'monthly', df[0])
time_series_group.append(ds)
input_dc = DataCollection('test1', time_series_group)
m = ModelESRNN(seasonality = [12], input_size = 4, output_size = 12, device=device)
train_dc, test_dc = input_dc.split(numTest = 12)
m.train(train_dc)
forecast_dc = m.predict(test_dc)
# train_dc.to_df().to_csv('insample.csv')
test_dc.to_df().to_csv('test.csv')
# forecast_dc.to_df().to_csv('forecast.csv')
mn = MN.ModelNaive2(2, train_dc)
naive2_dc = mn.fit_and_generate_prediction(12, 'MS')
naive2_dc.to_df().to_csv('naive.csv')
mp = MP.ModelPerformance("test model performance", 2, test_dc, forecast_dc, train_dc, naive2_dc)
mase = MP.MASE(test_dc.to_df(), forecast_dc.to_df(), train_dc.to_df(), 2)
smape = MP.sMAPE(test_dc.to_df(), forecast_dc.to_df())
mape = MP.MAPE(mp.y_df, mp.y_hat_df)
r2 = MP.R2(test_dc.to_df(), forecast_dc.to_df())
rmse = MP.RMSE(test_dc.to_df(), forecast_dc.to_df())
owa = MP.OWA(test_dc.to_df(), forecast_dc.to_df(), train_dc.to_df(), naive2_dc.to_df(), 2)
u1 = MP.Theil_U1(test_dc.to_df(), forecast_dc.to_df())
u2 = MP.Theil_U2(test_dc.to_df(), forecast_dc.to_df())
mp.MASE()
mp.sMAPE()
mp.MAPE()
mp.R2()
mp.RMSE()
mp.OWA()
mp.Theil_U1()
mp.Theil_U2()
self.assertAlmostEqual(mp.metrics['sMAPE'], smape)
self.assertAlmostEqual(mp.metrics['MAPE'], mape)
self.assertAlmostEqual(mp.metrics['R2'], r2)
self.assertAlmostEqual(mp.metrics['RMSE'], rmse)
self.assertAlmostEqual(mp.metrics['MASE'], mase)
self.assertAlmostEqual(mp.metrics['OWA'], owa)
self.assertAlmostEqual(mp.metrics['Theil_U1'], u1)
self.assertAlmostEqual(mp.metrics['Theil_U2'], u2)
def model_ESRNN(train_dc: DataCollection, test_dc: DataCollection, input_size = 5, output_size = 252, num_epoch = 15, batch_size = 64, dilations = [[1,5]], seasonality = [5,7]):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
m = ModelESRNN(max_epochs = num_epoch, seasonality = seasonality, batch_size = batch_size,
input_size = input_size, output_size = output_size, dilations = dilations, device = device)
m.train(train_dc)
forecast_dc = m.predict(test_dc)
forecast_df = forecast_dc.to_df()
forecast_df.to_csv('main_esrnn_predict_result.csv')
return train_dc, test_dc, forecast_dc
def test_data_reformat(self):
X, y = ModelESRNN().data_reformat(self.collect)
expect = pd.DataFrame({'unique_id':['ABC']*4 + ['KKK']*3,
'ds':X['ds'],
'x':['ETF']*4 + ['Bond']*3,
'y':[10.20, 12.00, 32.10, 9.32, 2.3, 3.6, 4.5]})
expect_x = expect[['unique_id', 'ds', 'x']]
expect_y = expect[['unique_id', 'ds', 'y']]
assert(X.equals(expect_x))
assert(y.equals(expect_y))
def test_ESRNN(self):
# An example of how to use ESRNN
import torch
device = 'cuda' if torch.cuda.is_available() else 'cpu'
path_daily = os.path.join('test','Data','daily')
dic_daily = preprocess.read_file(path_daily)
series_list = []
for k, v in dic_daily.items():
df, cat = v
df = preprocess.single_price(df, k)
series_list.append(DataSeries(cat, 'daily', df))
collect = DataCollection('test1', series_list)
m = ModelESRNN(max_epochs = 5, seasonality = [], batch_size = 64, input_size = 12, output_size = 12, device = device)
train_dc, test_dc = collect.split(numTest = 12)
m.train(train_dc)
y_test = m.predict(test_dc)
assert(isinstance(y_test, DataCollection))
y_test_df = y_test.to_df()
y_test_df.to_csv('predict_result.csv')
def test_data_reverse_to_dc(self):
# test reverse
result = pd.DataFrame({'unique_id':['ABC'] * 4 + ['KKK'] * 3,
'ds':pd.to_datetime(['2020-01-01','2020-02-01','2020-03-01','2020-04-01',
'2020-01-01','2020-02-01','2020-03-01']),
'x': ['ETF'] * 4 + ['Bond'] * 3,
'y_hat': [10.2, 12, 32.1, 9.32,
2.3, 3.6, 4.5]})
dc = ModelESRNN().to_dc(result, 'trial', {'ABC': 'monthly', 'KKK': 'monthly'})
for this, that in zip(dc, self.collect):
assert(self.compareSeries(this, that))
def validation_rolling(input_dc: DataCollection,
num_split: int,
numTest: int,
max_epochs=15,
batch_size=1,
batch_size_test=128,
freq_of_test=-1,
learning_rate=1e-3,
lr_scheduler_step_size=9,
lr_decay=0.9,
per_series_lr_multip=1.0,
gradient_eps=1e-8,
gradient_clipping_threshold=20,
rnn_weight_decay=0,
noise_std=0.001,
level_variability_penalty=80,
testing_percentile=50,
training_percentile=50,
ensemble=False,
cell_type='LSTM',
state_hsize=40,
dilations=[[1, 2], [4, 8]],
add_nl_layer=False,
seasonality=[4],
input_size=4,
output_size=8,
frequency=None,
max_periods=20,
random_seed=1):
import time
scores_list = []
train_val_dic = {}
device = 'cuda' if torch.cuda.is_available() else 'cpu'
for i in range(num_split):
train, validation = input_dc.split(numTest=numTest)
train_val_dic[i] = [train, validation]
input_dc = train
# record score of error
total_score = 0
elapse = 0
for i in range(num_split - 1, -1, -1):
train_dc = train_val_dic[i][0]
validation_dc = train_val_dic[i][1]
validation_df = validation_dc.to_df()
start_time = time.time()
m = ModelESRNN(max_epochs=max_epochs,
batch_size=batch_size,
batch_size_test=batch_size_test,
freq_of_test=freq_of_test,
learning_rate=learning_rate,
lr_scheduler_step_size=lr_scheduler_step_size,
lr_decay=lr_decay,
per_series_lr_multip=per_series_lr_multip,
gradient_eps=gradient_eps,
gradient_clipping_threshold=gradient_clipping_threshold,
rnn_weight_decay=rnn_weight_decay,
noise_std=noise_std,
level_variability_penalty=level_variability_penalty,
testing_percentile=testing_percentile,
training_percentile=training_percentile,
ensemble=ensemble,
cell_type=cell_type,
state_hsize=state_hsize,
dilations=dilations,
add_nl_layer=add_nl_layer,
seasonality=seasonality,
input_size=input_size,
output_size=output_size,
frequency=frequency,
max_periods=max_periods,
random_seed=random_seed,
device=device)
m.train(train_dc)
y_predict = m.predict(validation_dc)
y_predict_df = y_predict.to_df()
score = MP.MAPE(validation_df, y_predict_df)
elapse += time.time() - start_time
scores_list.append(score)
total_score += score
score = total_score / num_split
return score, scores_list, elapse / num_split, (max_epochs, batch_size,
input_size, output_size)
def validation_simple(
input_dc: DataCollection,
numTest: int,
max_epochs=15,
batch_size=1,
batch_size_test=128,
freq_of_test=-1,
learning_rate=1e-3,
lr_scheduler_step_size=9,
lr_decay=0.9,
per_series_lr_multip=1.0,
gradient_eps=1e-8,
gradient_clipping_threshold=20,
rnn_weight_decay=0,
noise_std=0.001,
level_variability_penalty=80,
testing_percentile=50,
training_percentile=50,
ensemble=False,
cell_type='LSTM',
state_hsize=40,
dilations=[[1, 2], [4, 8]],
add_nl_layer=False,
seasonality=[4],
input_size=4,
output_size=8,
frequency=None,
max_periods=20,
random_seed=1,
):
train_dc, validation_dc = input_dc.split(numTest=numTest)
validation_df = validation_dc.to_df()
device = 'cuda' if torch.cuda.is_available() else 'cpu'
m = ModelESRNN(max_epochs=max_epochs,
batch_size=batch_size,
batch_size_test=batch_size_test,
freq_of_test=freq_of_test,
learning_rate=learning_rate,
lr_scheduler_step_size=lr_scheduler_step_size,
lr_decay=lr_decay,
per_series_lr_multip=per_series_lr_multip,
gradient_eps=gradient_eps,
gradient_clipping_threshold=gradient_clipping_threshold,
rnn_weight_decay=rnn_weight_decay,
noise_std=noise_std,
level_variability_penalty=level_variability_penalty,
testing_percentile=testing_percentile,
training_percentile=training_percentile,
ensemble=ensemble,
cell_type=cell_type,
state_hsize=state_hsize,
dilations=dilations,
add_nl_layer=add_nl_layer,
seasonality=seasonality,
input_size=input_size,
output_size=output_size,
frequency=frequency,
max_periods=max_periods,
random_seed=random_seed,
device=device)
m.train(train_dc)
y_predict = m.predict(validation_dc)
y_predict_df = y_predict.to_df()
score = MP.MAPE(validation_df, y_predict_df)
return score, (max_epochs, batch_size, input_size, output_size)