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_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 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)