├── .gitignore ├── LICENSE ├── README.md ├── assets ├── ci_cd.PNG └── compare.PNG ├── data_provider ├── data_factory.py └── data_loader.py ├── exp ├── exp_GBRT.py ├── exp_basic.py └── exp_main.py ├── layers ├── Embed.py ├── SelfAttention_Family.py ├── Transformer_EncDec.py └── utils.py ├── models ├── DLinear.py ├── DeepVAR.py ├── GBRT.py ├── Informer.py ├── Linear.py ├── MLP.py ├── NHITS.py ├── NLinear.py ├── TCN.py └── Transformer.py ├── requirements.txt ├── run.py ├── scripts ├── loss │ └── Transformer_mae_mse.sh ├── low_rank │ └── Transformer.sh ├── performance │ ├── channel_dependent │ │ ├── DeepVAR.sh │ │ ├── GBRT.sh │ │ ├── Informer.sh │ │ ├── Linear.sh │ │ ├── MLP.sh │ │ ├── TCN.sh │ │ └── Transformer.sh │ └── channel_independent │ │ ├── DeepVAR.sh │ │ ├── GBRT.sh │ │ ├── Informer.sh │ │ ├── Linear.sh │ │ ├── MLP.sh │ │ ├── TCN.sh │ │ └── Transformer.sh ├── prreg │ ├── Transformer.sh │ ├── Transformer_CI.sh │ ├── linear.sh │ └── linear_CI.sh └── seq_len │ ├── Transformer.sh │ ├── Transformer_ci.sh │ ├── linear.sh │ └── linear_ci.sh └── utils ├── masking.py ├── metrics.py ├── timefeatures.py └── tools.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | checkpoints/ 12 | script/ 13 | .idea/ 14 | build/ 15 | develop-eggs/ 16 | dist/ 17 | downloads/ 18 | eggs/ 19 | .eggs/ 20 | lib/ 21 | lib64/ 22 | parts/ 23 | sdist/ 24 | var/ 25 | wheels/ 26 | share/python-wheels/ 27 | *.egg-info/ 28 | .installed.cfg 29 | *.egg 30 | MANIFEST 31 | 32 | # PyInstaller 33 | # Usually these files are written by a python script from a template 34 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 35 | *.manifest 36 | *.spec 37 | 38 | # Installer logs 39 | pip-log.txt 40 | pip-delete-this-directory.txt 41 | 42 | # Unit test / coverage reports 43 | htmlcov/ 44 | .tox/ 45 | .nox/ 46 | .coverage 47 | .coverage.* 48 | .cache 49 | nosetests.xml 50 | coverage.xml 51 | *.cover 52 | *.py,cover 53 | .hypothesis/ 54 | .pytest_cache/ 55 | cover/ 56 | 57 | # Translations 58 | *.mo 59 | *.pot 60 | 61 | # Django stuff: 62 | *.log 63 | local_settings.py 64 | db.sqlite3 65 | db.sqlite3-journal 66 | 67 | # Flask stuff: 68 | instance/ 69 | .webassets-cache 70 | 71 | # Scrapy stuff: 72 | .scrapy 73 | 74 | # Sphinx documentation 75 | docs/_build/ 76 | 77 | # PyBuilder 78 | .pybuilder/ 79 | target/ 80 | 81 | # Jupyter Notebook 82 | .ipynb_checkpoints 83 | 84 | # IPython 85 | profile_default/ 86 | ipython_config.py 87 | 88 | # pyenv 89 | # For a library or package, you might want to ignore these files since the code is 90 | # intended to run in multiple environments; otherwise, check them in: 91 | # .python-version 92 | 93 | # pipenv 94 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 95 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 96 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 97 | # install all needed dependencies. 98 | #Pipfile.lock 99 | 100 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 101 | __pypackages__/ 102 | 103 | # Celery stuff 104 | celerybeat-schedule 105 | celerybeat.pid 106 | 107 | # SageMath parsed files 108 | *.sage.py 109 | 110 | # Environments 111 | .env 112 | .venv 113 | env/ 114 | venv/ 115 | ENV/ 116 | env.bak/ 117 | venv.bak/ 118 | # Spyder project settings 119 | .spyderproject 120 | .spyproject 121 | 122 | # Rope project settings 123 | .ropeproject 124 | 125 | # mkdocs documentation 126 | /site 127 | 128 | # mypy 129 | .mypy_cache/ 130 | .dmypy.json 131 | dmypy.json 132 | 133 | # Pyre type checker 134 | .pyre/ 135 | 136 | # pytype static type analyzer 137 | .pytype/ 138 | 139 | # Cython debug symbols 140 | cython_debug/ -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 DAMO Academy @ Alibaba 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # The Capacity and Robustness Trade-off: Revisiting the Channel Independent Strategy for Multivariate Time Series Forecasting 2 | 3 | The code repository for "[The Capacity and Robustness Trade-off: Revisiting the Channel Independent Strategy for Multivariate Time Series Forecasting](https://arxiv.org/abs/2304.05206)" in PyTorch. If you use any content of this repo for your work, please cite the following bib entry: 4 | 5 | ``` 6 | @article{han2024capacity, 7 | title={The capacity and robustness trade-off: Revisiting the channel independent strategy for multivariate time series forecasting}, 8 | author={Han, Lu and Ye, Han-Jia and Zhan, De-Chuan}, 9 | journal={IEEE Transactions on Knowledge and Data Engineering}, 10 | year={2024}, 11 | publisher={IEEE} 12 | } 13 | ``` 14 | 15 | 16 | ## Abstract 17 | 18 | Multivariate time series data comprises various channels of variables. The multivariate forecasting models need to capture the relationship between the channels to accurately predict future values. However, recently, there has been an emergence of methods that employ the Channel Independent (CI) strategy. These methods view multivariate time series data as separate univariate time series and disregard the correlation between channels. Surprisingly, our empirical results have shown that models trained with the CI strategy outperform those trained with the Channel Dependent (CD) strategy, usually by a significant margin. Nevertheless, the reasons behind this phenomenon have not yet been thoroughly explored in the literature. This paper provides comprehensive empirical and theoretical analyses of the characteristics of multivariate time series datasets and the CI/CD strategy. Our results conclude that the CD approach has higher capacity but often lacks robustness to accurately predict distributionally drifted time series. In contrast, the CI approach trades capacity for robust prediction. Practical measures inspired by these analyses are proposed to address the capacity and robustness dilemma, including a modified CD method called Predict Residuals with Regularization (PRReg) that can surpass the CI strategy. We hope our findings can raise awareness among researchers about the characteristics of multivariate time series and inspire the construction of better forecasting models. 19 | 20 | **The Channel Dependent (CD) and Channel Independent (CI) Strategy**: 21 | 22 | 23 | 24 | **Performance comparison**: 25 | 26 | 27 | 28 | 29 | ## Prerequisites 30 | 31 | - matplotlib==3.5.1 32 | - numpy==1.23.4 33 | - pandas==1.2.3 34 | - torch==1.11.0 35 | - tqdm==4.62.3 36 | - xgboost==1.7.4 37 | 38 | 39 | ## Datasets 40 | 41 | We refer to [this repository](https://github.com/thuml/Autoformer#get-started) for downloading datasets. 42 | 43 | 44 | ## Scripts 45 | 46 | ### Results in Table.2 47 | 48 | To reproduce the Channel Dependent (CD) results in Table.2. Run the script files under folder `scripts/performance/channel_dependent`. For example run Transformer (CD) by 49 | 50 | > sh scripts/performance/channel_dependent/Transformer.sh 51 | 52 | To reproduce the Channel Independent (CI) results in Table.2. Run the script files under folder `scripts/performance/channel_independent`. For example run Transformer (CI) by 53 | 54 | > sh scripts/performance/channel_independent/Transformer.sh 55 | 56 | 57 | ### Results of Figure.9 58 | 59 | Run the script file under folder `scripts/low_rank`. 60 | 61 | > sh scripts/low_rank/Transformer.sh 62 | 63 | 64 | ### Results of PRReg 65 | 66 | To reproduce the PRReg results in Table.4. Run the script files under folder `scripts/prreg`. For example run Transformer (PRReg) by 67 | 68 | > sh scripts/prreg/Transformer.sh 69 | 70 | ### Results of Table.5 71 | 72 | Run the script files under folder `scripts/loss`: 73 | 74 | 75 | > sh scripts/loss/Transformer_mae_mse.sh 76 | 77 | 78 | ## Acknowledgement 79 | 80 | We appreciate the following github repos a lot for their valuable code base or datasets: 81 | 82 | https://github.com/zhouhaoyi/Informer2020 83 | 84 | https://github.com/thuml/Autoformer 85 | 86 | https://github.com/Daniela-Shereen/GBRT-for-TSF 87 | 88 | https://github.com/unit8co/darts 89 | 90 | https://github.com/zhouhaoyi/ETDataset 91 | 92 | https://github.com/laiguokun/multivariate-time-series-data 93 | -------------------------------------------------------------------------------- /assets/ci_cd.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/hanlu-nju/channel_independent_MTSF/7480baa4cdfa87ea89c01068beed03bf585a00c6/assets/ci_cd.PNG -------------------------------------------------------------------------------- /assets/compare.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/hanlu-nju/channel_independent_MTSF/7480baa4cdfa87ea89c01068beed03bf585a00c6/assets/compare.PNG -------------------------------------------------------------------------------- /data_provider/data_factory.py: -------------------------------------------------------------------------------- 1 | from data_provider.data_loader import Dataset_ETT_hour, Dataset_ETT_minute, Dataset_Custom, Dataset_Pred 2 | from torch.utils.data import DataLoader 3 | 4 | data_dict = { 5 | 'ETTh1': Dataset_ETT_hour, 6 | 'ETTh2': Dataset_ETT_hour, 7 | 'ETTm1': Dataset_ETT_minute, 8 | 'ETTm2': Dataset_ETT_minute, 9 | 'custom': Dataset_Custom, 10 | } 11 | 12 | 13 | def data_provider(args, flag): 14 | Data = data_dict[args.data] 15 | timeenc = 0 if args.embed != 'timeF' else 1 16 | 17 | if flag == 'test': 18 | shuffle_flag = False 19 | drop_last = False 20 | batch_size = args.batch_size 21 | freq = args.freq 22 | elif flag == 'pred': 23 | shuffle_flag = False 24 | drop_last = False 25 | batch_size = 1 26 | freq = args.detail_freq 27 | Data = Dataset_Pred 28 | else: 29 | shuffle_flag = True 30 | drop_last = True 31 | batch_size = args.batch_size 32 | freq = args.freq 33 | 34 | data_set = Data( 35 | root_path=args.root_path, 36 | data_path=args.data_path, 37 | flag=flag, 38 | size=[args.seq_len, args.label_len, args.pred_len], 39 | features=args.features, 40 | target=args.target, 41 | timeenc=timeenc, 42 | channel_independent=args.channel_independent, 43 | freq=freq, 44 | scale=args.scale, 45 | device=args.device 46 | ) 47 | print(flag, len(data_set)) 48 | data_loader = DataLoader( 49 | data_set, 50 | batch_size=batch_size, 51 | shuffle=shuffle_flag, 52 | num_workers=args.num_workers, 53 | drop_last=drop_last) 54 | return data_set, data_loader 55 | -------------------------------------------------------------------------------- /exp/exp_GBRT.py: -------------------------------------------------------------------------------- 1 | import os 2 | import warnings 3 | 4 | import numpy as np 5 | import torch.nn as nn 6 | from numpy.lib.stride_tricks import sliding_window_view 7 | 8 | from data_provider.data_factory import data_provider 9 | from exp.exp_basic import Exp_Basic 10 | from models import GBRT 11 | from utils.metrics import metric, MSE 12 | 13 | warnings.filterwarnings('ignore') 14 | 15 | 16 | 17 | def create_sub_series(series: np.ndarray, window_len: int, horizon: int, glob=False): 18 | subseries = sliding_window_view(series, window_len + horizon, axis=0) 19 | batch = subseries.shape[0] 20 | channel = subseries.shape[1] 21 | X, Y = subseries[:, :, :window_len], subseries[:, :, window_len:] 22 | if glob: 23 | X = X.reshape((batch * channel, -1)) 24 | Y = Y.reshape((batch * channel, -1)) 25 | else: 26 | X = X.reshape((batch, -1)) 27 | Y = Y.reshape((batch, -1)) 28 | return X, Y 29 | 30 | 31 | class Exp_GBRT(Exp_Basic): 32 | def __init__(self, args): 33 | super(Exp_GBRT, self).__init__(args) 34 | if self.args.channel_independent: 35 | # if self.args.channel_independent: 36 | # self.args.batch_size = int(np.ceil(self.args.batch_size / self.args.enc_in)) 37 | self.args.c_out = self.args.enc_in = self.args.dec_in = 1 38 | self.model = GBRT.Model(self.args) 39 | 40 | def _build_model(self): 41 | return nn.Identity() 42 | 43 | def _get_data(self, flag): 44 | data_set, data_loader = data_provider(self.args, flag) 45 | return data_set, data_loader 46 | 47 | def vali(self, vali_data, vali_loader, criterion): 48 | total_loss = [] 49 | return total_loss 50 | 51 | def train(self, setting): 52 | train_data, train_loader = self._get_data(flag='train') 53 | vali_data, vali_loader = self._get_data(flag='val') 54 | test_data, test_loader = self._get_data(flag='test') 55 | train_X, train_Y = create_sub_series(train_data.data_x, self.args.seq_len, self.args.pred_len, 56 | self.args.channel_independent) 57 | val_X, val_Y = create_sub_series(vali_data.data_x, self.args.seq_len, self.args.pred_len, 58 | self.args.channel_independent) 59 | test_X, test_Y = create_sub_series(test_data.data_x, self.args.seq_len, self.args.pred_len, 60 | self.args.channel_independent) 61 | print("data loaded") 62 | self.model.fit(train_X, train_Y) 63 | print("model fitted") 64 | val_pred = self.model.predict(val_X) 65 | test_pred = self.model.predict(test_X) 66 | 67 | print(f'valid loss : {MSE(val_pred, val_Y)}, test loss: {MSE(test_Y, test_pred)}') 68 | return self.model 69 | 70 | def test(self, setting, test=0): 71 | test_data, test_loader = self._get_data(flag='test') 72 | test_X, test_Y = create_sub_series(test_data.data_x, self.args.seq_len, self.args.pred_len, 73 | self.args.channel_independent) 74 | 75 | preds = self.model.predict(test_X) 76 | trues = test_Y 77 | print('test shape:', preds.shape, trues.shape) 78 | 79 | # result save 80 | folder_path = './results/' + setting + '/' 81 | if not os.path.exists(folder_path): 82 | os.makedirs(folder_path) 83 | 84 | mae, mse, rmse, mape, mspe = metric(preds, trues) 85 | 86 | print('mse:{}, mae:{}, rmse:{}'.format(mse, mae, rmse)) 87 | 88 | return 89 | -------------------------------------------------------------------------------- /exp/exp_basic.py: -------------------------------------------------------------------------------- 1 | import os 2 | import torch 3 | import numpy as np 4 | 5 | 6 | class Exp_Basic(object): 7 | def __init__(self, args): 8 | self.args = args 9 | args.device = self.device = self._acquire_device() 10 | self.model = self._build_model().to(self.device) 11 | 12 | def _build_model(self): 13 | raise NotImplementedError 14 | 15 | def _acquire_device(self): 16 | if self.args.use_gpu: 17 | os.environ["CUDA_VISIBLE_DEVICES"] = str( 18 | self.args.gpu) if not self.args.use_multi_gpu else self.args.devices 19 | device = torch.device('cuda:{}'.format(self.args.gpu)) 20 | print('Use GPU: cuda:{}'.format(self.args.gpu)) 21 | else: 22 | device = torch.device('cpu') 23 | print('Use CPU') 24 | return device 25 | 26 | def _get_data(self, *args, **kwargs): 27 | pass 28 | 29 | def vali(self, *args, **kwargs): 30 | pass 31 | 32 | def train(self, *args, **kwargs): 33 | pass 34 | 35 | def test(self, *args, **kwargs): 36 | pass 37 | -------------------------------------------------------------------------------- /exp/exp_main.py: -------------------------------------------------------------------------------- 1 | import os 2 | import time 3 | import warnings 4 | 5 | import numpy as np 6 | import torch 7 | import torch.nn as nn 8 | from torch import optim 9 | from tqdm import tqdm 10 | 11 | from data_provider.data_factory import data_provider 12 | from exp.exp_basic import Exp_Basic 13 | from models import Informer, Transformer, DeepVAR, DLinear, NLinear, Linear, TCN, MLP 14 | from utils.metrics import metric 15 | from utils.tools import EarlyStopping, adjust_learning_rate 16 | 17 | warnings.filterwarnings('ignore') 18 | 19 | 20 | class Exp_Main(Exp_Basic): 21 | def __init__(self, args): 22 | super(Exp_Main, self).__init__(args) 23 | 24 | def _build_model(self): 25 | model_dict = { 26 | 'Transformer': Transformer, 27 | 'Informer': Informer, 28 | 'DeepVAR': DeepVAR, 29 | 'DLinear': DLinear, 30 | 'NLinear': NLinear, 31 | 'Linear': Linear, 32 | 'TCN': TCN, 33 | 'MLP': MLP, 34 | } 35 | if self.args.channel_independent: 36 | self.args.c_out = self.args.enc_in = self.args.dec_in = 1 37 | 38 | model = model_dict[self.args.model].Model(self.args).float() 39 | 40 | if self.args.use_multi_gpu and self.args.use_gpu: 41 | model = nn.DataParallel(model, device_ids=self.args.device_ids) 42 | return model 43 | 44 | def _get_data(self, flag): 45 | data_set, data_loader = data_provider(self.args, flag) 46 | return data_set, data_loader 47 | 48 | def _select_optimizer(self): 49 | model_optim = optim.Adam(self.model.parameters(), lr=self.args.learning_rate, weight_decay=self.args.wd) 50 | return model_optim 51 | 52 | def _select_criterion(self, criterion_str): 53 | criterion_dict = {"mse": nn.MSELoss(), 54 | "mae": nn.L1Loss(), 55 | "huber": nn.SmoothL1Loss(beta=self.args.huber_beta)} 56 | criterion = criterion_dict[criterion_str] 57 | return criterion 58 | 59 | def vali(self, vali_data, vali_loader, criterion): 60 | total_loss = [] 61 | self.model.eval() 62 | with torch.no_grad(): 63 | for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(vali_loader): 64 | batch_x = batch_x.float().to(self.device) 65 | batch_y = batch_y.float() 66 | if self.args.pred_residual: 67 | seq_last = batch_x[:, -1:, :].detach() 68 | batch_x = batch_x - seq_last 69 | batch_x_mark = batch_x_mark.float().to(self.device) 70 | batch_y_mark = batch_y_mark.float().to(self.device) 71 | 72 | # decoder input 73 | dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float() 74 | dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device) 75 | 76 | if self.args.use_amp: 77 | with torch.cuda.amp.autocast(): 78 | if self.args.output_attention: 79 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] 80 | else: 81 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) 82 | else: 83 | if self.args.output_attention: 84 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] 85 | else: 86 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) 87 | f_dim = -1 if self.args.features == 'MS' else 0 88 | batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device) 89 | outputs = outputs[:, -self.args.pred_len:, f_dim:] 90 | if self.args.pred_residual: 91 | outputs = outputs + seq_last 92 | pred = outputs.detach().cpu() 93 | true = batch_y.detach().cpu() 94 | 95 | loss = criterion(pred, true) 96 | 97 | total_loss.append(loss) 98 | total_loss = np.average(total_loss) 99 | self.model.train() 100 | return total_loss 101 | 102 | def train(self, setting): 103 | train_data, train_loader = self._get_data(flag='train') 104 | vali_data, vali_loader = self._get_data(flag='val') 105 | test_data, test_loader = self._get_data(flag='test') 106 | 107 | path = os.path.join(self.args.checkpoints, setting) 108 | if not os.path.exists(path): 109 | os.makedirs(path) 110 | 111 | time_now = time.time() 112 | 113 | train_steps = len(train_loader) 114 | early_stopping = EarlyStopping(patience=self.args.patience, verbose=True) 115 | 116 | model_optim = self._select_optimizer() 117 | criterion = self._select_criterion(self.args.train_loss) 118 | 119 | if self.args.use_amp: 120 | scaler = torch.cuda.amp.GradScaler() 121 | 122 | for epoch in range(self.args.train_epochs): 123 | iter_count = 0 124 | train_loss = [] 125 | 126 | self.model.train() 127 | epoch_time = time.time() 128 | for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in tqdm(enumerate(train_loader), 129 | total=min(len(train_loader), 130 | self.args.max_iter)): 131 | iter_count += 1 132 | model_optim.zero_grad(set_to_none=True) 133 | 134 | batch_x = batch_x.float().to(self.device) 135 | if self.args.pred_residual: 136 | seq_last = batch_x[:, -1:, :].detach() 137 | batch_x = batch_x - seq_last 138 | 139 | batch_y = batch_y.float().to(self.device) 140 | batch_x_mark = batch_x_mark.float().to(self.device) 141 | batch_y_mark = batch_y_mark.float().to(self.device) 142 | # decoder input 143 | dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float() 144 | dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to( 145 | self.device) 146 | 147 | 148 | # encoder - decoder 149 | if self.args.use_amp: 150 | with torch.cuda.amp.autocast(): 151 | if self.args.output_attention: 152 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] 153 | else: 154 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) 155 | 156 | # f_dim = -1 if self.args.features == 'MS' else 0 157 | # batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device) 158 | # loss = criterion(outputs, batch_y) 159 | # train_loss.append(loss.item()) 160 | else: 161 | if self.args.output_attention: 162 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] 163 | else: 164 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) 165 | 166 | f_dim = -1 if self.args.features == 'MS' else 0 167 | 168 | batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device) 169 | outputs = outputs[:, -self.args.pred_len:, f_dim:] 170 | if self.args.inverse_scale: 171 | outputs = train_data.inverse_transform(outputs) # outputs.detach().cpu().numpy() # .squeeze() 172 | batch_y = train_data.inverse_transform(batch_y) # batch_y.detach().cpu().numpy() # .squeeze() 173 | if self.args.pred_residual: 174 | outputs = outputs + seq_last 175 | loss = criterion(outputs, batch_y) 176 | 177 | train_loss.append(loss.item()) 178 | # wandb.log({'train loss': loss.item()}) 179 | if (i + 1) % 100 == 0: 180 | # print("\titers: {0}, epoch: {1} | loss: {2:.7f}".format(i + 1, epoch + 1, loss.item())) 181 | speed = (time.time() - time_now) / iter_count 182 | left_time = speed * ((self.args.train_epochs - epoch) * train_steps - i) 183 | # print('\tspeed: {:.4f}s/iter; left time: {:.4f}s'.format(speed, left_time)) 184 | iter_count = 0 185 | time_now = time.time() 186 | 187 | if self.args.use_amp: 188 | scaler.scale(loss).backward() 189 | scaler.step(model_optim) 190 | scaler.update() 191 | else: 192 | loss.backward() 193 | model_optim.step() 194 | if i >= self.args.max_iter: 195 | break 196 | 197 | print("Epoch: {} cost time: {}".format(epoch + 1, time.time() - epoch_time)) 198 | train_loss = np.average(train_loss) 199 | vali_loss = self.vali(vali_data, vali_loader, criterion) 200 | test_loss = self.vali(test_data, test_loader, criterion) 201 | # wandb.log({'valid loss': vali_loss.item(), 'test loss': test_loss.item()}) 202 | print("Epoch: {0}, Steps: {1} | Train Loss: {2:.7f} Vali Loss: {3:.7f} Test Loss: {4:.7f}".format( 203 | epoch + 1, train_steps, train_loss, vali_loss, test_loss)) 204 | early_stopping(vali_loss, self.model, path) 205 | if early_stopping.early_stop: 206 | print("Early stopping") 207 | break 208 | 209 | adjust_learning_rate(model_optim, epoch + 1, self.args) 210 | 211 | best_model_path = path + '/' + 'checkpoint.pth' 212 | self.model.load_state_dict(torch.load(best_model_path)) 213 | 214 | import shutil 215 | shutil.rmtree(path) 216 | return self.model 217 | 218 | def test(self, setting, test=0): 219 | test_data, test_loader = self._get_data(flag='test') 220 | if test: 221 | print('loading model') 222 | self.model.load_state_dict(torch.load(os.path.join('./checkpoints/' + setting, 'checkpoint.pth'))) 223 | 224 | preds = [] 225 | trues = [] 226 | inputx = [] 227 | folder_path = './test_results/' + setting + '/' 228 | if not os.path.exists(folder_path): 229 | os.makedirs(folder_path) 230 | 231 | self.model.eval() 232 | with torch.no_grad(): 233 | for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in tqdm(enumerate(test_loader), 234 | total=len(test_loader)): 235 | batch_x = batch_x.float().to(self.device) 236 | batch_y = batch_y.float().to(self.device) 237 | if self.args.pred_residual: 238 | seq_last = batch_x[:, -1:, :].detach() 239 | batch_x = batch_x - seq_last 240 | batch_x_mark = batch_x_mark.float().to(self.device) 241 | batch_y_mark = batch_y_mark.float().to(self.device) 242 | 243 | # decoder input 244 | dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float() 245 | dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device) 246 | 247 | # encoder - decoder 248 | if self.args.use_amp: 249 | with torch.cuda.amp.autocast(): 250 | if self.args.output_attention: 251 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] 252 | else: 253 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) 254 | else: 255 | if self.args.output_attention: 256 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] 257 | 258 | else: 259 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) 260 | 261 | f_dim = -1 if self.args.features == 'MS' else 0 262 | 263 | outputs = outputs[:, -self.args.pred_len:, f_dim:] 264 | batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device) 265 | 266 | if self.args.inverse_scale or self.args.eval_rescale: 267 | outputs = test_data.inverse_transform(outputs) # outputs.detach().cpu().numpy() # .squeeze() 268 | batch_y = test_data.inverse_transform(batch_y) # batch_y.detach().cpu().numpy() # .squeeze() 269 | if self.args.pred_residual: 270 | outputs = outputs + seq_last 271 | pred = outputs.detach().cpu().numpy() # outputs.detach().cpu().numpy() # .squeeze() 272 | true = batch_y.detach().cpu().numpy() # batch_y.detach().cpu().numpy() # .squeeze() 273 | inputx.append(batch_x.detach().cpu().numpy()) 274 | preds.append(pred) 275 | trues.append(true) 276 | 277 | preds = np.concatenate(preds) 278 | trues = np.concatenate(trues) 279 | inputx = np.concatenate(inputx) 280 | if self.args.channel_independent: 281 | total = preds.shape[0] 282 | batch = total // test_data.channels 283 | preds = preds.reshape((batch, test_data.channels, -1)).transpose(0, 2, 1) 284 | trues = trues.reshape((batch, test_data.channels, -1)).transpose(0, 2, 1) 285 | inputx = inputx.reshape((batch, test_data.channels, -1)).transpose(0, 2, 1) 286 | print('test shape:', preds.shape, trues.shape) 287 | 288 | os.path.join('./checkpoints/' + setting, 'checkpoint.pth') 289 | 290 | # result save 291 | # folder_path = './results/' + setting + '/' 292 | # if not os.path.exists(folder_path): 293 | # os.makedirs(folder_path) 294 | 295 | # np.save(os.path.join(folder_path, "prediction.npy"), preds) 296 | # np.save(os.path.join(folder_path, "trues.npy"), trues) 297 | # np.save(os.path.join(folder_path, "inputx.npy"), inputx) 298 | 299 | mae, mse, rmse, mape, mspe = metric(preds, trues) 300 | print('mse:{}, mae:{}, rmse:{}'.format(mse, mae, rmse)) 301 | 302 | return 303 | 304 | def predict(self, setting, load=False): 305 | pred_data, pred_loader = self._get_data(flag='pred') 306 | 307 | if load: 308 | path = os.path.join(self.args.checkpoints, setting) 309 | best_model_path = path + '/' + 'checkpoint.pth' 310 | self.model.load_state_dict(torch.load(best_model_path)) 311 | 312 | preds = [] 313 | 314 | self.model.eval() 315 | with torch.no_grad(): 316 | for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(pred_loader): 317 | batch_x = batch_x.float().to(self.device) 318 | batch_y = batch_y.float() 319 | if self.args.pred_residual: 320 | seq_last = batch_x[:, -1:, :].detach() 321 | batch_x = batch_x - seq_last 322 | batch_x_mark = batch_x_mark.float().to(self.device) 323 | batch_y_mark = batch_y_mark.float().to(self.device) 324 | 325 | # decoder input 326 | dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float() 327 | dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device) 328 | # encoder - decoder 329 | if self.args.use_amp: 330 | with torch.cuda.amp.autocast(): 331 | if self.args.output_attention: 332 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] 333 | else: 334 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) 335 | else: 336 | if self.args.output_attention: 337 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] 338 | else: 339 | outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) 340 | if self.args.pred_residual: 341 | outputs = outputs + seq_last 342 | pred = outputs.detach().cpu().numpy() # .squeeze() 343 | preds.append(pred) 344 | 345 | preds = np.array(preds) 346 | preds = preds.reshape(-1, preds.shape[-2], preds.shape[-1]) 347 | 348 | # result save 349 | folder_path = './results/' + setting + '/' 350 | if not os.path.exists(folder_path): 351 | os.makedirs(folder_path) 352 | 353 | np.save(folder_path + 'real_prediction.npy', preds) 354 | 355 | return 356 | -------------------------------------------------------------------------------- /layers/Embed.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | from torch.nn.utils import weight_norm 5 | import math 6 | from layers.utils import conv1d 7 | 8 | 9 | class PositionalEmbedding(nn.Module): 10 | def __init__(self, d_model, max_len=5000): 11 | super(PositionalEmbedding, self).__init__() 12 | # Compute the positional encodings once in log space. 13 | pe = torch.zeros(max_len, d_model).float() 14 | pe.require_grad = False 15 | 16 | position = torch.arange(0, max_len).float().unsqueeze(1) 17 | div_term = (torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model)).exp() 18 | 19 | pe[:, 0::2] = torch.sin(position * div_term) 20 | pe[:, 1::2] = torch.cos(position * div_term) 21 | 22 | pe = pe.unsqueeze(0) 23 | self.register_buffer('pe', pe) 24 | 25 | def forward(self, x): 26 | return self.pe[:, :x.size(1)] 27 | 28 | 29 | class TokenEmbedding(nn.Module): 30 | def __init__(self, c_in, d_model): 31 | super(TokenEmbedding, self).__init__() 32 | padding = 1 if torch.__version__ >= '1.5.0' else 2 33 | self.tokenConv = conv1d(in_channels=c_in, out_channels=d_model, 34 | kernel_size=3, padding=padding, padding_mode='circular', bias=False) 35 | for m in self.modules(): 36 | if isinstance(m, nn.Conv1d): 37 | nn.init.kaiming_normal_(m.weight, mode='fan_in', nonlinearity='leaky_relu') 38 | 39 | def forward(self, x): 40 | x = self.tokenConv(x.permute(0, 2, 1)).transpose(1, 2) 41 | return x 42 | 43 | 44 | class FixedEmbedding(nn.Module): 45 | def __init__(self, c_in, d_model): 46 | super(FixedEmbedding, self).__init__() 47 | 48 | w = torch.zeros(c_in, d_model).float() 49 | w.require_grad = False 50 | 51 | position = torch.arange(0, c_in).float().unsqueeze(1) 52 | div_term = (torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model)).exp() 53 | 54 | w[:, 0::2] = torch.sin(position * div_term) 55 | w[:, 1::2] = torch.cos(position * div_term) 56 | 57 | self.emb = nn.Embedding(c_in, d_model) 58 | self.emb.weight = nn.Parameter(w, requires_grad=False) 59 | 60 | def forward(self, x): 61 | return self.emb(x).detach() 62 | 63 | 64 | class TemporalEmbedding(nn.Module): 65 | def __init__(self, d_model, embed_type='fixed', freq='h'): 66 | super(TemporalEmbedding, self).__init__() 67 | 68 | minute_size = 4 69 | hour_size = 24 70 | weekday_size = 7 71 | day_size = 32 72 | month_size = 13 73 | 74 | Embed = FixedEmbedding if embed_type == 'fixed' else nn.Embedding 75 | if freq == 't': 76 | self.minute_embed = Embed(minute_size, d_model) 77 | self.hour_embed = Embed(hour_size, d_model) 78 | self.weekday_embed = Embed(weekday_size, d_model) 79 | self.day_embed = Embed(day_size, d_model) 80 | self.month_embed = Embed(month_size, d_model) 81 | 82 | def forward(self, x): 83 | x = x.long() 84 | 85 | minute_x = self.minute_embed(x[:, :, 4]) if hasattr(self, 'minute_embed') else 0. 86 | hour_x = self.hour_embed(x[:, :, 3]) 87 | weekday_x = self.weekday_embed(x[:, :, 2]) 88 | day_x = self.day_embed(x[:, :, 1]) 89 | month_x = self.month_embed(x[:, :, 0]) 90 | 91 | return hour_x + weekday_x + day_x + month_x + minute_x 92 | 93 | 94 | class TimeFeatureEmbedding(nn.Module): 95 | def __init__(self, d_model, embed_type='timeF', freq='h'): 96 | super(TimeFeatureEmbedding, self).__init__() 97 | 98 | freq_map = {'h': 4, 't': 5, 's': 6, 'm': 1, 'a': 1, 'w': 2, 'd': 3, 'b': 3} 99 | d_inp = freq_map[freq] 100 | self.embed = nn.Linear(d_inp, d_model, bias=False) 101 | 102 | def forward(self, x): 103 | return self.embed(x) 104 | 105 | 106 | class DataEmbedding(nn.Module): 107 | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropout=0.1): 108 | super(DataEmbedding, self).__init__() 109 | 110 | self.value_embedding = TokenEmbedding(c_in=c_in, d_model=d_model) 111 | self.position_embedding = PositionalEmbedding(d_model=d_model) 112 | self.temporal_embedding = TemporalEmbedding(d_model=d_model, embed_type=embed_type, 113 | freq=freq) if embed_type != 'timeF' else TimeFeatureEmbedding( 114 | d_model=d_model, embed_type=embed_type, freq=freq) 115 | self.dropout = nn.Dropout(p=dropout) 116 | 117 | def forward(self, x, x_mark): 118 | x = self.value_embedding(x) + self.temporal_embedding(x_mark) + self.position_embedding(x) 119 | return self.dropout(x) 120 | 121 | 122 | class DataEmbedding_onlypos(nn.Module): 123 | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropout=0.1): 124 | super(DataEmbedding_onlypos, self).__init__() 125 | 126 | self.value_embedding = TokenEmbedding(c_in=c_in, d_model=d_model) 127 | self.position_embedding = PositionalEmbedding(d_model=d_model) 128 | self.dropout = nn.Dropout(p=dropout) 129 | 130 | def forward(self, x, x_mark): 131 | x = self.value_embedding(x) + self.position_embedding(x) 132 | return self.dropout(x) 133 | 134 | 135 | class DataEmbedding_wo_pos(nn.Module): 136 | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropout=0.1): 137 | super(DataEmbedding_wo_pos, self).__init__() 138 | 139 | self.value_embedding = TokenEmbedding(c_in=c_in, d_model=d_model) 140 | self.position_embedding = PositionalEmbedding(d_model=d_model) 141 | self.temporal_embedding = TemporalEmbedding(d_model=d_model, embed_type=embed_type, 142 | freq=freq) if embed_type != 'timeF' else TimeFeatureEmbedding( 143 | d_model=d_model, embed_type=embed_type, freq=freq) 144 | self.dropout = nn.Dropout(p=dropout) 145 | 146 | def forward(self, x, x_mark): 147 | # try: 148 | x = self.value_embedding(x) + self.temporal_embedding(x_mark) 149 | # except: 150 | # a = 1 151 | return self.dropout(x) 152 | -------------------------------------------------------------------------------- /layers/SelfAttention_Family.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | 5 | import matplotlib.pyplot as plt 6 | 7 | import numpy as np 8 | import math 9 | from math import sqrt 10 | from utils.masking import TriangularCausalMask, ProbMask 11 | import os 12 | 13 | 14 | class FullAttention(nn.Module): 15 | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dropout=0.1, output_attention=False): 16 | super(FullAttention, self).__init__() 17 | self.scale = scale 18 | self.mask_flag = mask_flag 19 | self.output_attention = output_attention 20 | self.dropout = nn.Dropout(attention_dropout) 21 | 22 | def forward(self, queries, keys, values, attn_mask): 23 | B, L, H, E = queries.shape 24 | _, S, _, D = values.shape 25 | scale = self.scale or 1. / sqrt(E) 26 | 27 | scores = torch.einsum("blhe,bshe->bhls", queries, keys) 28 | 29 | if self.mask_flag: 30 | if attn_mask is None: 31 | attn_mask = TriangularCausalMask(B, L, device=queries.device) 32 | 33 | scores.masked_fill_(attn_mask.mask, -np.inf) 34 | 35 | A = self.dropout(torch.softmax(scale * scores, dim=-1)) 36 | V = torch.einsum("bhls,bshd->blhd", A, values) 37 | 38 | if self.output_attention: 39 | return (V.contiguous(), A) 40 | else: 41 | return (V.contiguous(), None) 42 | 43 | 44 | class ProbAttention(nn.Module): 45 | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dropout=0.1, output_attention=False): 46 | super(ProbAttention, self).__init__() 47 | self.factor = factor 48 | self.scale = scale 49 | self.mask_flag = mask_flag 50 | self.output_attention = output_attention 51 | self.dropout = nn.Dropout(attention_dropout) 52 | 53 | def _prob_QK(self, Q, K, sample_k, n_top): # n_top: c*ln(L_q) 54 | # Q [B, H, L, D] 55 | B, H, L_K, E = K.shape 56 | _, _, L_Q, _ = Q.shape 57 | 58 | # calculate the sampled Q_K 59 | K_expand = K.unsqueeze(-3).expand(B, H, L_Q, L_K, E) 60 | index_sample = torch.randint(L_K, (L_Q, sample_k)) # real U = U_part(factor*ln(L_k))*L_q 61 | K_sample = K_expand[:, :, torch.arange(L_Q).unsqueeze(1), index_sample, :] 62 | Q_K_sample = torch.matmul(Q.unsqueeze(-2), K_sample.transpose(-2, -1)).squeeze() 63 | 64 | # find the Top_k query with sparisty measurement 65 | M = Q_K_sample.max(-1)[0] - torch.div(Q_K_sample.sum(-1), L_K) 66 | M_top = M.topk(n_top, sorted=False)[1] 67 | 68 | # use the reduced Q to calculate Q_K 69 | Q_reduce = Q[torch.arange(B)[:, None, None], 70 | torch.arange(H)[None, :, None], 71 | M_top, :] # factor*ln(L_q) 72 | Q_K = torch.matmul(Q_reduce, K.transpose(-2, -1)) # factor*ln(L_q)*L_k 73 | 74 | return Q_K, M_top 75 | 76 | def _get_initial_context(self, V, L_Q): 77 | B, H, L_V, D = V.shape 78 | if not self.mask_flag: 79 | # V_sum = V.sum(dim=-2) 80 | V_sum = V.mean(dim=-2) 81 | contex = V_sum.unsqueeze(-2).expand(B, H, L_Q, V_sum.shape[-1]).clone() 82 | else: # use mask 83 | assert (L_Q == L_V) # requires that L_Q == L_V, i.e. for self-attention only 84 | contex = V.cumsum(dim=-2) 85 | return contex 86 | 87 | def _update_context(self, context_in, V, scores, index, L_Q, attn_mask): 88 | B, H, L_V, D = V.shape 89 | 90 | if self.mask_flag: 91 | attn_mask = ProbMask(B, H, L_Q, index, scores, device=V.device) 92 | scores.masked_fill_(attn_mask.mask, -np.inf) 93 | 94 | attn = torch.softmax(scores, dim=-1) # nn.Softmax(dim=-1)(scores) 95 | 96 | context_in[torch.arange(B)[:, None, None], 97 | torch.arange(H)[None, :, None], 98 | index, :] = torch.matmul(attn, V).type_as(context_in) 99 | if self.output_attention: 100 | attns = (torch.ones([B, H, L_V, L_V]) / L_V).type_as(attn).to(attn.device) 101 | attns[torch.arange(B)[:, None, None], torch.arange(H)[None, :, None], index, :] = attn 102 | return (context_in, attns) 103 | else: 104 | return (context_in, None) 105 | 106 | def forward(self, queries, keys, values, attn_mask): 107 | B, L_Q, H, D = queries.shape 108 | _, L_K, _, _ = keys.shape 109 | 110 | queries = queries.transpose(2, 1) 111 | keys = keys.transpose(2, 1) 112 | values = values.transpose(2, 1) 113 | 114 | U_part = self.factor * np.ceil(np.log(L_K)).astype('int').item() # c*ln(L_k) 115 | u = self.factor * np.ceil(np.log(L_Q)).astype('int').item() # c*ln(L_q) 116 | 117 | U_part = U_part if U_part < L_K else L_K 118 | u = u if u < L_Q else L_Q 119 | 120 | scores_top, index = self._prob_QK(queries, keys, sample_k=U_part, n_top=u) 121 | 122 | # add scale factor 123 | scale = self.scale or 1. / sqrt(D) 124 | if scale is not None: 125 | scores_top = scores_top * scale 126 | # get the context 127 | context = self._get_initial_context(values, L_Q) 128 | # update the context with selected top_k queries 129 | context, attn = self._update_context(context, values, scores_top, index, L_Q, attn_mask) 130 | 131 | return context.contiguous(), attn 132 | 133 | 134 | class LowRankLinear(nn.Module): 135 | 136 | def __init__(self, in_features: int, out_features: int, bias: bool = True, rank: int = None) -> None: 137 | super().__init__() 138 | if rank is None: 139 | rank = min(in_features, out_features) 140 | self.lora_A = nn.Linear(in_features, rank, bias=False) 141 | self.lora_B = nn.Linear(rank, out_features, bias=bias) 142 | 143 | def forward(self, x): 144 | return self.lora_B(self.lora_A(x)) 145 | 146 | 147 | class AttentionLayer(nn.Module): 148 | def __init__(self, attention, d_model, n_heads, d_keys=None, 149 | d_values=None, low_rank=False, rank_ratio=1): 150 | super(AttentionLayer, self).__init__() 151 | 152 | d_keys = d_keys or (d_model // n_heads) 153 | d_values = d_values or (d_model // n_heads) 154 | 155 | self.inner_attention = attention 156 | self.query_projection = nn.Linear(d_model, d_keys * n_heads) 157 | self.key_projection = nn.Linear(d_model, d_keys * n_heads) 158 | self.value_projection = nn.Linear(d_model, d_values * n_heads) 159 | input_dim = d_values * n_heads 160 | output_dim = d_model 161 | if low_rank: 162 | print("low rank projection") 163 | max_rank = min(input_dim, output_dim) 164 | rank = max(max_rank // rank_ratio, 1) 165 | self.out_projection = nn.Sequential(nn.Linear(input_dim, rank, bias=False), 166 | nn.Linear(rank, output_dim)) 167 | else: 168 | print("full rank projection") 169 | self.out_projection = nn.Linear(input_dim, output_dim) 170 | # self.out_projection = nn.Linear(d_values * n_heads, d_model) 171 | # self.out_projection = out_projection(d_values * n_heads, d_model) 172 | self.n_heads = n_heads 173 | 174 | def forward(self, queries, keys, values, attn_mask): 175 | B, L, _ = queries.shape 176 | _, S, _ = keys.shape 177 | H = self.n_heads 178 | 179 | queries = self.query_projection(queries).view(B, L, H, -1) 180 | keys = self.key_projection(keys).view(B, S, H, -1) 181 | values = self.value_projection(values).view(B, S, H, -1) 182 | 183 | out, attn = self.inner_attention( 184 | queries, 185 | keys, 186 | values, 187 | attn_mask 188 | ) 189 | out = out.view(B, L, -1) 190 | 191 | return self.out_projection(out), attn 192 | -------------------------------------------------------------------------------- /layers/Transformer_EncDec.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | from layers.utils import conv1d 5 | 6 | 7 | class ConvLayer(nn.Module): 8 | def __init__(self, c_in): 9 | super(ConvLayer, self).__init__() 10 | self.downConv = conv1d(in_channels=c_in, 11 | out_channels=c_in, 12 | kernel_size=3, 13 | padding=2, 14 | padding_mode='circular') 15 | self.norm = nn.BatchNorm1d(c_in) 16 | self.activation = nn.ELU() 17 | self.maxPool = nn.MaxPool1d(kernel_size=3, stride=2, padding=1) 18 | 19 | def forward(self, x): 20 | x = self.downConv(x.permute(0, 2, 1)) 21 | x = self.norm(x) 22 | x = self.activation(x) 23 | x = self.maxPool(x) 24 | x = x.transpose(1, 2) 25 | return x 26 | 27 | 28 | class EncoderLayer(nn.Module): 29 | def __init__(self, attention, d_model, d_ff=None, dropout=0.1, activation="relu"): 30 | super(EncoderLayer, self).__init__() 31 | d_ff = d_ff or 4 * d_model 32 | self.attention = attention 33 | self.conv1 = conv1d(in_channels=d_model, out_channels=d_ff, kernel_size=1) 34 | self.conv2 = conv1d(in_channels=d_ff, out_channels=d_model, kernel_size=1) 35 | self.norm1 = nn.LayerNorm(d_model) 36 | self.norm2 = nn.LayerNorm(d_model) 37 | self.dropout = nn.Dropout(dropout) 38 | self.activation = F.relu if activation == "relu" else F.gelu 39 | 40 | def forward(self, x, attn_mask=None): 41 | new_x, attn = self.attention( 42 | x, x, x, 43 | attn_mask=attn_mask 44 | ) 45 | x = x + self.dropout(new_x) 46 | 47 | y = x = self.norm1(x) 48 | y = self.dropout(self.activation(self.conv1(y.transpose(-1, 1)))) 49 | y = self.dropout(self.conv2(y).transpose(-1, 1)) 50 | 51 | return self.norm2(x + y), attn 52 | 53 | 54 | class Encoder(nn.Module): 55 | def __init__(self, attn_layers, conv_layers=None, norm_layer=None): 56 | super(Encoder, self).__init__() 57 | self.attn_layers = nn.ModuleList(attn_layers) 58 | self.conv_layers = nn.ModuleList(conv_layers) if conv_layers is not None else None 59 | self.norm = norm_layer 60 | 61 | def forward(self, x, attn_mask=None): 62 | # x [B, L, D] 63 | attns = [] 64 | if self.conv_layers is not None: 65 | for attn_layer, conv_layer in zip(self.attn_layers, self.conv_layers): 66 | x, attn = attn_layer(x, attn_mask=attn_mask) 67 | x = conv_layer(x) 68 | attns.append(attn) 69 | x, attn = self.attn_layers[-1](x) 70 | attns.append(attn) 71 | else: 72 | for attn_layer in self.attn_layers: 73 | x, attn = attn_layer(x, attn_mask=attn_mask) 74 | attns.append(attn) 75 | 76 | if self.norm is not None: 77 | x = self.norm(x) 78 | 79 | return x, attns 80 | 81 | 82 | class DecoderLayer(nn.Module): 83 | def __init__(self, self_attention, cross_attention, d_model, d_ff=None, 84 | dropout=0.1, activation="relu"): 85 | super(DecoderLayer, self).__init__() 86 | d_ff = d_ff or 4 * d_model 87 | self.self_attention = self_attention 88 | self.cross_attention = cross_attention 89 | self.conv1 = conv1d(in_channels=d_model, out_channels=d_ff, kernel_size=1) 90 | self.conv2 = conv1d(in_channels=d_ff, out_channels=d_model, kernel_size=1) 91 | self.norm1 = nn.LayerNorm(d_model) 92 | self.norm2 = nn.LayerNorm(d_model) 93 | self.norm3 = nn.LayerNorm(d_model) 94 | self.dropout = nn.Dropout(dropout) 95 | self.activation = F.relu if activation == "relu" else F.gelu 96 | 97 | def forward(self, x, cross, x_mask=None, cross_mask=None): 98 | x = x + self.dropout(self.self_attention( 99 | x, x, x, 100 | attn_mask=x_mask 101 | )[0]) 102 | x = self.norm1(x) 103 | 104 | x = x + self.dropout(self.cross_attention( 105 | x, cross, cross, 106 | attn_mask=cross_mask 107 | )[0]) 108 | 109 | y = x = self.norm2(x) 110 | y = self.dropout(self.activation(self.conv1(y.transpose(-1, 1)))) 111 | y = self.dropout(self.conv2(y).transpose(-1, 1)) 112 | 113 | return self.norm3(x + y) 114 | 115 | 116 | class Decoder(nn.Module): 117 | def __init__(self, layers, norm_layer=None, projection=None): 118 | super(Decoder, self).__init__() 119 | self.layers = nn.ModuleList(layers) 120 | self.norm = norm_layer 121 | self.projection = projection 122 | 123 | def forward(self, x, cross, x_mask=None, cross_mask=None): 124 | for layer in self.layers: 125 | x = layer(x, cross, x_mask=x_mask, cross_mask=cross_mask) 126 | 127 | if self.norm is not None: 128 | x = self.norm(x) 129 | 130 | if self.projection is not None: 131 | x = self.projection(x) 132 | return x 133 | -------------------------------------------------------------------------------- /layers/utils.py: -------------------------------------------------------------------------------- 1 | from typing import Union 2 | 3 | import numpy as np 4 | import torch 5 | import torch.nn as nn 6 | from torch import Tensor 7 | from torch.nn.common_types import _size_1_t 8 | from torch.nn.parameter import Parameter 9 | 10 | 11 | class ConvShared(nn.Conv1d): 12 | 13 | def __init__(self, in_channels: int, out_channels: int, kernel_size: _size_1_t, stride: _size_1_t = 1, 14 | padding: Union[str, _size_1_t] = 0, dilation: _size_1_t = 1, groups: int = 1, bias: bool = True, 15 | padding_mode: str = 'zeros', device=None, dtype=None) -> None: 16 | super().__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode, 17 | device, dtype) 18 | factory_kwargs = {'device': device, 'dtype': dtype} 19 | self.weight = Parameter(torch.empty( 20 | (self.out_channels, 1, *self.kernel_size), **factory_kwargs)) 21 | if bias: 22 | self.bias = Parameter(torch.empty(self.out_channels, **factory_kwargs)) 23 | 24 | def forward(self, input: Tensor) -> Tensor: 25 | repeat = [1] * len(self.weight.shape) 26 | repeat[1] = self.in_channels // self.groups 27 | return self._conv_forward(input, self.weight.repeat(*repeat), self.bias) 28 | 29 | 30 | CONV_TYPE = 'normal' 31 | 32 | 33 | def set_conv_type(args): 34 | global CONV_TYPE 35 | CONV_TYPE = args.conv_type 36 | 37 | 38 | def conv1d(*args, **kwargs): 39 | global CONV_TYPE 40 | if CONV_TYPE == 'share': 41 | kwargs['groups'] = kwargs['in_channels'] 42 | kwargs['out_channels'] = int(np.ceil(kwargs['out_channels'] / kwargs['in_channels'])) * kwargs['in_channels'] 43 | return ConvShared(*args, **kwargs) 44 | elif CONV_TYPE == 'depth': 45 | kwargs['groups'] = kwargs['in_channels'] 46 | kwargs['out_channels'] = int(np.ceil(kwargs['out_channels'] / kwargs['in_channels'])) * kwargs['in_channels'] 47 | return nn.Conv1d(*args, **kwargs) 48 | else: 49 | return nn.Conv1d(*args, **kwargs) 50 | 51 | 52 | 53 | def phi_(phi_c, x, lb=0, ub=1): 54 | mask = np.logical_or(x < lb, x > ub) * 1.0 55 | return np.polynomial.polynomial.Polynomial(phi_c)(x) * (1 - mask) 56 | 57 | 58 | 59 | 60 | def train(model, train_loader, optimizer, epoch, device, verbose=0, 61 | lossFn=None, lr_schedule=None, 62 | post_proc=lambda args: args): 63 | if lossFn is None: 64 | lossFn = nn.MSELoss() 65 | 66 | model.train() 67 | 68 | total_loss = 0. 69 | 70 | for batch_idx, (data, target) in enumerate(train_loader): 71 | bs = len(data) 72 | data, target = data.to(device), target.to(device) 73 | optimizer.zero_grad() 74 | 75 | output = model(data) 76 | 77 | target = post_proc(target) 78 | output = post_proc(output) 79 | loss = lossFn(output.view(bs, -1), target.view(bs, -1)) 80 | 81 | loss.backward() 82 | optimizer.step() 83 | total_loss += loss.sum().item() 84 | if lr_schedule is not None: lr_schedule.step() 85 | 86 | if verbose > 0: 87 | print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( 88 | epoch, batch_idx * len(data), len(train_loader.dataset), 89 | 100. * batch_idx / len(train_loader), loss.item())) 90 | 91 | return total_loss / len(train_loader.dataset) 92 | 93 | 94 | def test(model, test_loader, device, verbose=0, lossFn=None, 95 | post_proc=lambda args: args): 96 | model.eval() 97 | if lossFn is None: 98 | lossFn = nn.MSELoss() 99 | 100 | total_loss = 0. 101 | predictions = [] 102 | 103 | with torch.no_grad(): 104 | for data, target in test_loader: 105 | bs = len(data) 106 | 107 | data, target = data.to(device), target.to(device) 108 | output = model(data) 109 | output = post_proc(output) 110 | 111 | loss = lossFn(output.view(bs, -1), target.view(bs, -1)) 112 | total_loss += loss.sum().item() 113 | 114 | return total_loss / len(test_loader.dataset) 115 | 116 | 117 | # Till EoF 118 | # taken from FNO paper: 119 | # https://github.com/zongyi-li/fourier_neural_operator 120 | 121 | # normalization, pointwise gaussian 122 | class UnitGaussianNormalizer(object): 123 | def __init__(self, x, eps=0.00001): 124 | super(UnitGaussianNormalizer, self).__init__() 125 | 126 | # x could be in shape of ntrain*n or ntrain*T*n or ntrain*n*T 127 | self.mean = torch.mean(x, 0) 128 | self.std = torch.std(x, 0) 129 | self.eps = eps 130 | 131 | def encode(self, x): 132 | x = (x - self.mean) / (self.std + self.eps) 133 | return x 134 | 135 | def decode(self, x, sample_idx=None): 136 | if sample_idx is None: 137 | std = self.std + self.eps # n 138 | mean = self.mean 139 | else: 140 | if len(self.mean.shape) == len(sample_idx[0].shape): 141 | std = self.std[sample_idx] + self.eps # batch*n 142 | mean = self.mean[sample_idx] 143 | if len(self.mean.shape) > len(sample_idx[0].shape): 144 | std = self.std[:, sample_idx] + self.eps # T*batch*n 145 | mean = self.mean[:, sample_idx] 146 | 147 | # x is in shape of batch*n or T*batch*n 148 | x = (x * std) + mean 149 | return x 150 | 151 | def cuda(self): 152 | self.mean = self.mean.cuda() 153 | self.std = self.std.cuda() 154 | 155 | def cpu(self): 156 | self.mean = self.mean.cpu() 157 | self.std = self.std.cpu() 158 | 159 | 160 | # normalization, Gaussian 161 | class GaussianNormalizer(object): 162 | def __init__(self, x, eps=0.00001): 163 | super(GaussianNormalizer, self).__init__() 164 | 165 | self.mean = torch.mean(x) 166 | self.std = torch.std(x) 167 | self.eps = eps 168 | 169 | def encode(self, x): 170 | x = (x - self.mean) / (self.std + self.eps) 171 | return x 172 | 173 | def decode(self, x, sample_idx=None): 174 | x = (x * (self.std + self.eps)) + self.mean 175 | return x 176 | 177 | def cuda(self): 178 | self.mean = self.mean.cuda() 179 | self.std = self.std.cuda() 180 | 181 | def cpu(self): 182 | self.mean = self.mean.cpu() 183 | self.std = self.std.cpu() 184 | 185 | 186 | # normalization, scaling by range 187 | class RangeNormalizer(object): 188 | def __init__(self, x, low=0.0, high=1.0): 189 | super(RangeNormalizer, self).__init__() 190 | mymin = torch.min(x, 0)[0].view(-1) 191 | mymax = torch.max(x, 0)[0].view(-1) 192 | 193 | self.a = (high - low) / (mymax - mymin) 194 | self.b = -self.a * mymax + high 195 | 196 | def encode(self, x): 197 | s = x.size() 198 | x = x.view(s[0], -1) 199 | x = self.a * x + self.b 200 | x = x.view(s) 201 | return x 202 | 203 | def decode(self, x): 204 | s = x.size() 205 | x = x.view(s[0], -1) 206 | x = (x - self.b) / self.a 207 | x = x.view(s) 208 | return x 209 | 210 | 211 | class LpLoss(object): 212 | def __init__(self, d=2, p=2, size_average=True, reduction=True): 213 | super(LpLoss, self).__init__() 214 | 215 | # Dimension and Lp-norm type are postive 216 | assert d > 0 and p > 0 217 | 218 | self.d = d 219 | self.p = p 220 | self.reduction = reduction 221 | self.size_average = size_average 222 | 223 | def abs(self, x, y): 224 | num_examples = x.size()[0] 225 | 226 | # Assume uniform mesh 227 | h = 1.0 / (x.size()[1] - 1.0) 228 | 229 | all_norms = (h ** (self.d / self.p)) * torch.norm(x.view(num_examples, -1) - y.view(num_examples, -1), self.p, 230 | 1) 231 | 232 | if self.reduction: 233 | if self.size_average: 234 | return torch.mean(all_norms) 235 | else: 236 | return torch.sum(all_norms) 237 | 238 | return all_norms 239 | 240 | def rel(self, x, y): 241 | num_examples = x.size()[0] 242 | 243 | diff_norms = torch.norm(x.reshape(num_examples, -1) - y.reshape(num_examples, -1), self.p, 1) 244 | y_norms = torch.norm(y.reshape(num_examples, -1), self.p, 1) 245 | 246 | if self.reduction: 247 | if self.size_average: 248 | return torch.mean(diff_norms / y_norms) 249 | else: 250 | return torch.sum(diff_norms / y_norms) 251 | 252 | return diff_norms / y_norms 253 | 254 | def __call__(self, x, y): 255 | return self.rel(x, y) 256 | -------------------------------------------------------------------------------- /models/DLinear.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | import numpy as np 5 | 6 | class moving_avg(nn.Module): 7 | """ 8 | Moving average block to highlight the trend of time series 9 | """ 10 | def __init__(self, kernel_size, stride): 11 | super(moving_avg, self).__init__() 12 | self.kernel_size = kernel_size 13 | self.avg = nn.AvgPool1d(kernel_size=kernel_size, stride=stride, padding=0) 14 | 15 | def forward(self, x): 16 | # padding on the both ends of time series 17 | front = x[:, 0:1, :].repeat(1, (self.kernel_size - 1) // 2, 1) 18 | end = x[:, -1:, :].repeat(1, (self.kernel_size - 1) // 2, 1) 19 | x = torch.cat([front, x, end], dim=1) 20 | x = self.avg(x.permute(0, 2, 1)) 21 | x = x.permute(0, 2, 1) 22 | return x 23 | 24 | 25 | class series_decomp(nn.Module): 26 | """ 27 | Series decomposition block 28 | """ 29 | def __init__(self, kernel_size): 30 | super(series_decomp, self).__init__() 31 | self.moving_avg = moving_avg(kernel_size, stride=1) 32 | 33 | def forward(self, x): 34 | moving_mean = self.moving_avg(x) 35 | res = x - moving_mean 36 | return res, moving_mean 37 | 38 | class Model(nn.Module): 39 | """ 40 | Decomposition-Linear 41 | """ 42 | def __init__(self, configs): 43 | super(Model, self).__init__() 44 | self.seq_len = configs.seq_len 45 | self.pred_len = configs.pred_len 46 | 47 | # Decompsition Kernel Size 48 | kernel_size = 25 49 | self.decompsition = series_decomp(kernel_size) 50 | self.individual = configs.individual 51 | self.channels = configs.enc_in 52 | 53 | if self.individual: 54 | self.Linear_Seasonal = nn.ModuleList() 55 | self.Linear_Trend = nn.ModuleList() 56 | 57 | for i in range(self.channels): 58 | self.Linear_Seasonal.append(nn.Linear(self.seq_len,self.pred_len)) 59 | self.Linear_Trend.append(nn.Linear(self.seq_len,self.pred_len)) 60 | 61 | # Use this two lines if you want to visualize the weights 62 | # self.Linear_Seasonal[i].weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len])) 63 | # self.Linear_Trend[i].weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len])) 64 | else: 65 | self.Linear_Seasonal = nn.Linear(self.seq_len,self.pred_len) 66 | self.Linear_Trend = nn.Linear(self.seq_len,self.pred_len) 67 | 68 | # Use this two lines if you want to visualize the weights 69 | # self.Linear_Seasonal.weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len])) 70 | # self.Linear_Trend.weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len])) 71 | 72 | def forward(self, x, *args, **kwargs): 73 | # x: [Batch, Input length, Channel] 74 | seasonal_init, trend_init = self.decompsition(x) 75 | seasonal_init, trend_init = seasonal_init.permute(0,2,1), trend_init.permute(0,2,1) 76 | if self.individual: 77 | seasonal_output = torch.zeros([seasonal_init.size(0),seasonal_init.size(1),self.pred_len],dtype=seasonal_init.dtype).to(seasonal_init.device) 78 | trend_output = torch.zeros([trend_init.size(0),trend_init.size(1),self.pred_len],dtype=trend_init.dtype).to(trend_init.device) 79 | for i in range(self.channels): 80 | seasonal_output[:,i,:] = self.Linear_Seasonal[i](seasonal_init[:,i,:]) 81 | trend_output[:,i,:] = self.Linear_Trend[i](trend_init[:,i,:]) 82 | else: 83 | seasonal_output = self.Linear_Seasonal(seasonal_init) 84 | trend_output = self.Linear_Trend(trend_init) 85 | 86 | x = seasonal_output + trend_output 87 | return x.permute(0,2,1) # to [Batch, Output length, Channel] 88 | -------------------------------------------------------------------------------- /models/DeepVAR.py: -------------------------------------------------------------------------------- 1 | # @author : ThinkPad 2 | # @date : 2022/10/20 3 | import torch.nn as nn 4 | 5 | from layers.Embed import DataEmbedding_wo_pos 6 | 7 | 8 | class Model(nn.Module): 9 | """ 10 | DeepVAR model 11 | """ 12 | 13 | def __init__(self, configs): 14 | super(Model, self).__init__() 15 | self.version = configs.version 16 | self.modes = configs.modes 17 | self.seq_len = configs.seq_len 18 | self.label_len = configs.label_len 19 | self.pred_len = configs.pred_len 20 | # self.enc_embedding = TokenEmbedding(configs.enc_in, configs.d_model) 21 | self.enc_embedding = DataEmbedding_wo_pos(configs.enc_in, configs.d_model, configs.embed, configs.freq, 22 | configs.dropout) 23 | self.lstm = nn.LSTM(input_size=configs.d_model, 24 | hidden_size=configs.d_model, 25 | num_layers=configs.e_layers, 26 | bias=True, 27 | dropout=configs.dropout, 28 | batch_first=True) 29 | self.adapterW = nn.Linear(configs.d_model, self.pred_len * configs.enc_in) 30 | 31 | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, 32 | enc_self_mask=None, dec_self_mask=None, dec_enc_mask=None): 33 | # decomp init 34 | # Parse windows_batch 35 | enc_out = self.enc_embedding(x_enc, x_mark_enc) 36 | # Flatten inputs [B, W, C, L+H] -> [B, W, C*(L+H)] 37 | # Concatenate [ Y_t, | X_{t-L},..., X_{t} | F_{t-L},..., F_{t+H} | S ] 38 | batch_size, windows_size = enc_out.shape[:2] 39 | 40 | # LSTM forward 41 | dec, _ = self.lstm(enc_out) 42 | out = self.adapterW(dec[:, -1, :]) 43 | 44 | return out.view(batch_size, self.pred_len, -1) 45 | -------------------------------------------------------------------------------- /models/GBRT.py: -------------------------------------------------------------------------------- 1 | # @author : ThinkPad 2 | # @date : 2022/10/20 3 | import torch 4 | import torch.nn as nn 5 | import torch.nn.functional as F 6 | import numpy as np 7 | import math 8 | from sklearn.multioutput import MultiOutputRegressor 9 | import xgboost as xgb 10 | 11 | 12 | class Model: 13 | """ 14 | Just one Linear layer 15 | """ 16 | 17 | def __init__(self, configs): 18 | super(Model, self).__init__() 19 | self.seq_len = configs.seq_len 20 | self.pred_len = configs.pred_len 21 | self.channels = configs.enc_in 22 | self.flat_input = configs.flat_input 23 | self.individual = configs.individual 24 | model = xgb.XGBRegressor(learning_rate=0.2, 25 | n_estimators=50, 26 | max_depth=8, 27 | min_child_weight=1, 28 | gamma=0.0, 29 | subsample=0.8, 30 | colsample_bytree=0.8, 31 | scale_pos_weight=1, 32 | seed=42) 33 | 34 | self.model = MultiOutputRegressor(model) 35 | 36 | # Use this line if you want to visualize the weights 37 | # self.Linear.weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len])) 38 | 39 | def fit(self, data_x, data_y): 40 | self.model.fit(data_x, data_y) 41 | 42 | def predict(self, data_x): 43 | return self.model.predict(data_x) 44 | -------------------------------------------------------------------------------- /models/Informer.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | from utils.masking import TriangularCausalMask, ProbMask 5 | from layers.Transformer_EncDec import Decoder, DecoderLayer, Encoder, EncoderLayer, ConvLayer 6 | from layers.SelfAttention_Family import FullAttention, ProbAttention, AttentionLayer 7 | from layers.Embed import DataEmbedding 8 | import numpy as np 9 | 10 | 11 | class Model(nn.Module): 12 | """ 13 | Informer with Propspare attention in O(LlogL) complexity 14 | """ 15 | def __init__(self, configs): 16 | super(Model, self).__init__() 17 | self.pred_len = configs.pred_len 18 | self.output_attention = configs.output_attention 19 | 20 | # Embedding 21 | self.enc_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, 22 | configs.dropout) 23 | self.dec_embedding = DataEmbedding(configs.dec_in, configs.d_model, configs.embed, configs.freq, 24 | configs.dropout) 25 | 26 | # Encoder 27 | self.encoder = Encoder( 28 | [ 29 | EncoderLayer( 30 | AttentionLayer( 31 | ProbAttention(False, configs.factor, attention_dropout=configs.dropout, 32 | output_attention=configs.output_attention), 33 | configs.d_model, configs.n_heads), 34 | configs.d_model, 35 | configs.d_ff, 36 | dropout=configs.dropout, 37 | activation=configs.activation 38 | ) for l in range(configs.e_layers) 39 | ], 40 | [ 41 | ConvLayer( 42 | configs.d_model 43 | ) for l in range(configs.e_layers - 1) 44 | ] if configs.distil else None, 45 | norm_layer=torch.nn.LayerNorm(configs.d_model) 46 | ) 47 | # Decoder 48 | self.decoder = Decoder( 49 | [ 50 | DecoderLayer( 51 | AttentionLayer( 52 | ProbAttention(True, configs.factor, attention_dropout=configs.dropout, output_attention=False), 53 | configs.d_model, configs.n_heads), 54 | AttentionLayer( 55 | ProbAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False), 56 | configs.d_model, configs.n_heads), 57 | configs.d_model, 58 | configs.d_ff, 59 | dropout=configs.dropout, 60 | activation=configs.activation, 61 | ) 62 | for l in range(configs.d_layers) 63 | ], 64 | norm_layer=torch.nn.LayerNorm(configs.d_model), 65 | projection=nn.Linear(configs.d_model, configs.c_out, bias=True) 66 | ) 67 | 68 | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, 69 | enc_self_mask=None, dec_self_mask=None, dec_enc_mask=None): 70 | 71 | enc_out = self.enc_embedding(x_enc, x_mark_enc) 72 | enc_out, attns = self.encoder(enc_out, attn_mask=enc_self_mask) 73 | 74 | dec_out = self.dec_embedding(x_dec, x_mark_dec) 75 | dec_out = self.decoder(dec_out, enc_out, x_mask=dec_self_mask, cross_mask=dec_enc_mask) 76 | 77 | if self.output_attention: 78 | return dec_out, attns 79 | else: 80 | return dec_out 81 | -------------------------------------------------------------------------------- /models/Linear.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | import numpy as np 5 | 6 | 7 | class Model(nn.Module): 8 | """ 9 | Just one Linear layer 10 | """ 11 | 12 | def __init__(self, configs): 13 | super(Model, self).__init__() 14 | self.seq_len = configs.seq_len 15 | self.pred_len = configs.pred_len 16 | self.channels = configs.enc_in 17 | self.flat_input = configs.flat_input 18 | self.individual = configs.individual 19 | self.Linear = self.get_linear_layer(configs) 20 | 21 | # Use this line if you want to visualize the weights 22 | # self.Linear.weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len])) 23 | 24 | def get_linear_layer(self, configs): 25 | if self.individual: 26 | return nn.ModuleList(nn.Linear(self.seq_len, self.pred_len) for _ in range(self.channels)) 27 | else: 28 | if self.flat_input: 29 | input_dim = self.seq_len * self.channels 30 | output_dim = self.pred_len * self.channels 31 | else: 32 | input_dim = self.seq_len 33 | output_dim = self.pred_len 34 | if configs.low_rank: 35 | max_rank = min(input_dim, output_dim) 36 | rank = max(max_rank // configs.rank_ratio, 1) 37 | return nn.Sequential(nn.Linear(input_dim, rank, bias=False), 38 | nn.Linear(rank, output_dim)) 39 | else: 40 | return nn.Linear(input_dim, output_dim) 41 | # if configs.low_rank: 42 | # return nn.Sequential(nn.Linear(self.seq_len, configs.rank, bias=False), 43 | # nn.Linear(configs.rank, self.pred_len)) 44 | # else: 45 | # return nn.Linear(self.seq_len, self.pred_len) 46 | 47 | def forward(self, batch_x, batch_x_mark, dec_inp, batch_y_mark): 48 | # x: [Batch, Input length, Channel] 49 | if self.individual: 50 | o = torch.zeros([batch_x.size(0), self.pred_len, batch_x.size(2)], 51 | dtype=batch_x.dtype).to(batch_x.device) 52 | for i in range(self.channels): 53 | o[:, :, i] = self.Linear[i](batch_x[:, :, i]) 54 | else: 55 | if self.flat_input: 56 | bz = batch_x.size(0) 57 | o = self.Linear(batch_x.view(bz, -1)).reshape(bz, self.pred_len, self.channels) 58 | else: 59 | o = self.Linear(batch_x.permute(0, 2, 1)).permute(0, 2, 1) 60 | return o # [Batch, Output length, Channel] 61 | -------------------------------------------------------------------------------- /models/MLP.py: -------------------------------------------------------------------------------- 1 | # @author : ThinkPad 2 | # @date : 2023/3/13 3 | import torch 4 | import torch.nn as nn 5 | import torch.nn.functional as F 6 | import numpy as np 7 | 8 | 9 | class Model(nn.Module): 10 | """ 11 | Just one Linear layer 12 | """ 13 | 14 | def __init__(self, configs): 15 | super(Model, self).__init__() 16 | self.seq_len = configs.seq_len 17 | self.pred_len = configs.pred_len 18 | self.channels = configs.enc_in 19 | input_dim = configs.seq_len * configs.enc_in 20 | out_dim = configs.pred_len * configs.enc_in 21 | hidden = min((input_dim + out_dim) // 8, 512) 22 | self.networks = nn.Sequential(nn.Linear(input_dim, hidden), 23 | nn.ReLU(inplace=True), 24 | nn.Linear(hidden, out_dim)) 25 | 26 | def forward(self, batch_x, batch_x_mark, dec_inp, batch_y_mark): 27 | # x: [Batch, Input length, Channel] 28 | bz = batch_x.size(0) 29 | o = self.networks(batch_x.view(bz, -1)).reshape(bz, self.pred_len, self.channels) 30 | return o # [Batch, Output length, Channel] 31 | -------------------------------------------------------------------------------- /models/NLinear.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | import numpy as np 5 | 6 | 7 | class Model(nn.Module): 8 | """ 9 | Normalization-Linear 10 | """ 11 | 12 | def __init__(self, configs): 13 | super(Model, self).__init__() 14 | self.seq_len = configs.seq_len 15 | self.pred_len = configs.pred_len 16 | 17 | # Use this line if you want to visualize the weights 18 | # self.Linear.weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len])) 19 | self.channels = configs.enc_in 20 | self.individual = configs.individual 21 | if self.individual: 22 | self.Linear = nn.ModuleList() 23 | for i in range(self.channels): 24 | self.Linear.append(nn.Linear(self.seq_len, self.pred_len)) 25 | else: 26 | self.Linear = nn.Linear(self.seq_len, self.pred_len) 27 | 28 | def forward(self, x, *args, **kwargs): 29 | # x: [Batch, Input length, Channel] 30 | seq_last = x[:, -1:, :].detach() 31 | x = x - seq_last 32 | if self.individual: 33 | output = torch.zeros([x.size(0), self.pred_len, x.size(2)], dtype=x.dtype).to(x.device) 34 | for i in range(self.channels): 35 | output[:, :, i] = self.Linear[i](x[:, :, i]) 36 | x = output 37 | else: 38 | x = self.Linear(x.permute(0, 2, 1)).permute(0, 2, 1) 39 | x = x + seq_last 40 | return x # [Batch, Output length, Channel] 41 | -------------------------------------------------------------------------------- /models/TCN.py: -------------------------------------------------------------------------------- 1 | # @author : ThinkPad 2 | # @date : 2023/3/13 3 | import torch 4 | import torch.nn as nn 5 | import torch.nn.functional as F 6 | import numpy as np 7 | import math 8 | 9 | 10 | class _ResidualBlock(nn.Module): 11 | def __init__( 12 | self, 13 | num_filters: int, 14 | kernel_size: int, 15 | dilation_base: int, 16 | dropout_fn, 17 | weight_norm: bool, 18 | nr_blocks_below: int, 19 | num_layers: int, 20 | input_size: int, 21 | target_size: int, 22 | ): 23 | """PyTorch module implementing a residual block module used in `_TCNModule`. 24 | 25 | Parameters 26 | ---------- 27 | num_filters 28 | The number of filters in a convolutional layer of the TCN. 29 | kernel_size 30 | The size of every kernel in a convolutional layer. 31 | dilation_base 32 | The base of the exponent that will determine the dilation on every level. 33 | dropout_fn 34 | The dropout function to be applied to every convolutional layer. 35 | weight_norm 36 | Boolean value indicating whether to use weight normalization. 37 | nr_blocks_below 38 | The number of residual blocks before the current one. 39 | num_layers 40 | The number of convolutional layers. 41 | input_size 42 | The dimensionality of the input time series of the whole network. 43 | target_size 44 | The dimensionality of the output time series of the whole network. 45 | 46 | Inputs 47 | ------ 48 | x of shape `(batch_size, in_dimension, input_chunk_length)` 49 | Tensor containing the features of the input sequence. 50 | in_dimension is equal to `input_size` if this is the first residual block, 51 | in all other cases it is equal to `num_filters`. 52 | 53 | Outputs 54 | ------- 55 | y of shape `(batch_size, out_dimension, input_chunk_length)` 56 | Tensor containing the output sequence of the residual block. 57 | out_dimension is equal to `output_size` if this is the last residual block, 58 | in all other cases it is equal to `num_filters`. 59 | """ 60 | super().__init__() 61 | 62 | self.dilation_base = dilation_base 63 | self.kernel_size = kernel_size 64 | self.dropout_fn = dropout_fn 65 | self.num_layers = num_layers 66 | self.nr_blocks_below = nr_blocks_below 67 | 68 | input_dim = input_size if nr_blocks_below == 0 else num_filters 69 | output_dim = target_size if nr_blocks_below == num_layers - 1 else num_filters 70 | self.conv1 = nn.Conv1d( 71 | input_dim, 72 | num_filters, 73 | kernel_size, 74 | dilation=(dilation_base ** nr_blocks_below), 75 | ) 76 | self.conv2 = nn.Conv1d( 77 | num_filters, 78 | output_dim, 79 | kernel_size, 80 | dilation=(dilation_base ** nr_blocks_below), 81 | ) 82 | if weight_norm: 83 | self.conv1, self.conv2 = nn.utils.weight_norm( 84 | self.conv1 85 | ), nn.utils.weight_norm(self.conv2) 86 | 87 | if input_dim != output_dim: 88 | self.conv3 = nn.Conv1d(input_dim, output_dim, 1) 89 | 90 | def forward(self, x): 91 | residual = x 92 | 93 | # first step 94 | left_padding = (self.dilation_base ** self.nr_blocks_below) * ( 95 | self.kernel_size - 1 96 | ) 97 | x = F.pad(x, (left_padding, 0)) 98 | x = self.dropout_fn(F.relu(self.conv1(x))) 99 | 100 | # second step 101 | x = F.pad(x, (left_padding, 0)) 102 | x = self.conv2(x) 103 | if self.nr_blocks_below < self.num_layers - 1: 104 | x = F.relu(x) 105 | x = self.dropout_fn(x) 106 | 107 | # add residual 108 | if self.conv1.in_channels != self.conv2.out_channels: 109 | residual = self.conv3(residual) 110 | x = x + residual 111 | 112 | return x 113 | 114 | 115 | class Model(nn.Module): 116 | def __init__(self, configs): 117 | super().__init__() 118 | self.seq_len = configs.seq_len 119 | self.pred_len = configs.pred_len 120 | 121 | kernel_size = 3 122 | num_filters = 3 123 | num_layers = None 124 | dilation_base = 2 125 | weight_norm = False 126 | dropout = 0.2 127 | nr_params = 1 128 | 129 | # self.input_size = input_size 130 | self.n_filters = num_filters 131 | self.kernel_size = kernel_size 132 | # self.target_length = target_length 133 | self.target_size = configs.enc_in 134 | self.nr_params = nr_params 135 | self.dilation_base = dilation_base 136 | self.dropout = nn.Dropout(p=dropout) 137 | 138 | # If num_layers is not passed, compute number of layers needed for full history coverage 139 | if num_layers is None and dilation_base > 1: 140 | num_layers = math.ceil( 141 | math.log( 142 | (self.seq_len - 1) 143 | * (dilation_base - 1) 144 | / (kernel_size - 1) 145 | / 2 146 | + 1, 147 | dilation_base, 148 | ) 149 | ) 150 | print("Number of layers chosen: " + str(num_layers)) 151 | elif num_layers is None: 152 | num_layers = math.ceil( 153 | (self.seq_len - 1) / (kernel_size - 1) / 2 154 | ) 155 | print("Number of layers chosen: " + str(num_layers)) 156 | self.num_layers = num_layers 157 | 158 | # Building TCN module 159 | self.res_blocks_list = [] 160 | for i in range(num_layers): 161 | res_block = _ResidualBlock( 162 | num_filters, 163 | kernel_size, 164 | dilation_base, 165 | self.dropout, 166 | weight_norm, 167 | i, 168 | num_layers, 169 | configs.enc_in, 170 | configs.enc_in * nr_params, 171 | ) 172 | self.res_blocks_list.append(res_block) 173 | self.res_blocks = nn.ModuleList(self.res_blocks_list) 174 | 175 | def forward(self, batch_x, batch_x_mark, dec_inp, batch_y_mark): 176 | x = batch_x 177 | # data is of size (batch_size, input_chunk_length, input_size) 178 | batch_size = x.size(0) 179 | x = x.transpose(1, 2) 180 | 181 | for res_block in self.res_blocks_list: 182 | x = res_block(x) 183 | 184 | x = x.transpose(1, 2) 185 | x = x.view( 186 | batch_size, self.seq_len, self.target_size 187 | ) 188 | 189 | return x 190 | -------------------------------------------------------------------------------- /models/Transformer.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | from layers.Transformer_EncDec import Decoder, DecoderLayer, Encoder, EncoderLayer, ConvLayer 5 | from layers.SelfAttention_Family import FullAttention, AttentionLayer 6 | from layers.Embed import DataEmbedding 7 | from functools import partial 8 | 9 | 10 | class Model(nn.Module): 11 | """ 12 | Vanilla Transformer with O(L^2) complexity 13 | """ 14 | 15 | def __init__(self, configs): 16 | super(Model, self).__init__() 17 | self.pred_len = configs.pred_len 18 | self.output_attention = configs.output_attention 19 | 20 | # Embedding 21 | self.enc_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, 22 | configs.dropout) 23 | self.dec_embedding = DataEmbedding(configs.dec_in, configs.d_model, configs.embed, configs.freq, 24 | configs.dropout) 25 | 26 | # Encoder 27 | self.encoder = Encoder( 28 | [ 29 | EncoderLayer( 30 | AttentionLayer( 31 | FullAttention( 32 | False, configs.factor, attention_dropout=configs.dropout, 33 | output_attention=configs.output_attention), 34 | configs.d_model, 35 | configs.n_heads, 36 | low_rank=configs.low_rank, 37 | rank_ratio=configs.rank_ratio 38 | ), 39 | configs.d_model, 40 | configs.d_ff, 41 | dropout=configs.dropout, 42 | activation=configs.activation, 43 | ) for l in range(configs.e_layers) 44 | ], 45 | norm_layer=torch.nn.LayerNorm(configs.d_model) 46 | ) 47 | # Decoder 48 | self.decoder = Decoder( 49 | [ 50 | DecoderLayer( 51 | AttentionLayer( 52 | FullAttention(True, configs.factor, attention_dropout=configs.dropout, output_attention=False), 53 | configs.d_model, configs.n_heads, low_rank=configs.low_rank, 54 | rank_ratio=configs.rank_ratio), 55 | AttentionLayer( 56 | FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False), 57 | configs.d_model, configs.n_heads, low_rank=configs.low_rank, 58 | rank_ratio=configs.rank_ratio), 59 | configs.d_model, 60 | configs.d_ff, 61 | dropout=configs.dropout, 62 | activation=configs.activation, 63 | ) 64 | for l in range(configs.d_layers) 65 | ], 66 | norm_layer=torch.nn.LayerNorm(configs.d_model), 67 | projection=nn.Linear(configs.d_model, configs.c_out, bias=True) 68 | ) 69 | 70 | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, 71 | enc_self_mask=None, dec_self_mask=None, dec_enc_mask=None): 72 | 73 | enc_out = self.enc_embedding(x_enc, x_mark_enc) 74 | enc_out, attns = self.encoder(enc_out, attn_mask=enc_self_mask) 75 | 76 | dec_out = self.dec_embedding(x_dec, x_mark_dec) 77 | dec_out = self.decoder(dec_out, enc_out, x_mask=dec_self_mask, cross_mask=dec_enc_mask) 78 | 79 | if self.output_attention: 80 | return dec_out, attns 81 | else: 82 | return dec_out 83 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | matplotlib==3.5.1 2 | numpy==1.23.4 3 | pandas==1.2.3 4 | torch==1.11.0 5 | tqdm==4.62.3 6 | xgboost==1.7.4 7 | -------------------------------------------------------------------------------- /run.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | import os 3 | import sys 4 | import torch 5 | 6 | import random 7 | import numpy as np 8 | from layers.utils import set_conv_type 9 | 10 | 11 | def get_intern_ip_address(): 12 | import socket 13 | try: 14 | s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 15 | s.connect(('8.8.8.8', 80)) 16 | ip = s.getsockname()[0] 17 | finally: 18 | s.close() 19 | return ip 20 | 21 | 22 | def main(): 23 | fix_seed = 2021 24 | random.seed(fix_seed) 25 | torch.manual_seed(fix_seed) 26 | np.random.seed(fix_seed) 27 | 28 | parser = argparse.ArgumentParser(description='Autoformer & Transformer family for Time Series Forecasting') 29 | 30 | # basic config 31 | parser.add_argument('--is_training', type=int, default=1, help='status') 32 | parser.add_argument('--task_id', type=str, default='test', help='task id') 33 | parser.add_argument('--tags', type=str, nargs="*", default=[], help='extra tags for wandb') 34 | parser.add_argument('--model', type=str, default='Linear', 35 | help='model name') 36 | 37 | parser.add_argument('--L', type=int, default=3, help='ignore level') 38 | parser.add_argument('--base', type=str, default='legendre', help='mwt base') 39 | parser.add_argument('--cross_activation', type=str, default='tanh', 40 | help='mwt cross atention activation function tanh or softmax') 41 | 42 | # data loader 43 | parser.add_argument('--data', type=str, default='ETTh1', help='dataset type') 44 | parser.add_argument('--root_path', type=str, default='/data/hanlu/ts-data/', help='root path of the data file') 45 | parser.add_argument('--data_path', type=str, default='ETTh1.csv', help='data file') 46 | parser.add_argument('--features', type=str, default='M', 47 | help='forecasting task, options:[M, S, MS]; M:multivariate predict multivariate, ' 48 | 'S:univariate predict univariate, MS:multivariate predict univariate') 49 | parser.add_argument('--target', type=str, default='OT', help='target feature in S or MS task') 50 | parser.add_argument('--freq', type=str, default='h', 51 | help='freq for time features encoding, options:[s:secondly, t:minutely, h:hourly, d:daily, ' 52 | 'b:business days, w:weekly, m:monthly], you can also use more detailed freq like 15min or 3h') 53 | parser.add_argument('--checkpoints', type=str, default='./checkpoints/', help='location of model checkpoints') 54 | parser.add_argument('--no_scale', dest='scale', action='store_false', default=True, help='do not use normalization') 55 | parser.add_argument('--inverse_scale', action='store_true', default=False, help='inverse the scale') 56 | parser.add_argument('--eval_rescale', action='store_true', default=False, help='inverse the scale') 57 | 58 | # forecasting task 59 | parser.add_argument('--seq_len', type=int, default=96, help='input sequence length') 60 | parser.add_argument('--label_len', type=int, default=48, help='start token length') 61 | parser.add_argument('--pred_len', type=int, default=96, help='prediction sequence length') 62 | # parser.add_argument('--cross_activation', type=str, default='tanh' 63 | 64 | # model define 65 | parser.add_argument('--conv_type', type=str, default='normal', help='share convolution weight') 66 | parser.add_argument('--enc_in', type=int, default=7, help='encoder input size') 67 | parser.add_argument('--dec_in', type=int, default=7, help='decoder input size') 68 | parser.add_argument('--c_out', type=int, default=7, help='output size') 69 | parser.add_argument('--d_model', type=int, default=512, help='dimension of model') 70 | parser.add_argument('--n_heads', type=int, default=8, help='num of heads') 71 | parser.add_argument('--e_layers', type=int, default=2, help='num of encoder layers') 72 | parser.add_argument('--d_layers', type=int, default=1, help='num of decoder layers') 73 | parser.add_argument('--d_ff', type=int, default=2048, help='dimension of fcn') 74 | parser.add_argument('--moving_avg', default=[24], help='window size of moving average') 75 | parser.add_argument('--factor', type=int, default=1, help='attn factor') 76 | parser.add_argument('--wavelet', type=int, default=0, help='use wavelet') 77 | parser.add_argument('--distil', action='store_false', 78 | help='whether to use distilling in encoder, using this argument means not using distilling', 79 | default=True) 80 | parser.add_argument('--channel_independent', action='store_true', 81 | help='weather train with global dataset', 82 | default=False) 83 | parser.add_argument('--dropout', type=float, default=0.05, help='dropout') 84 | parser.add_argument('--embed', type=str, default='timeF', 85 | help='time features encoding, options:[timeF, fixed, learned]') 86 | parser.add_argument('--activation', type=str, default='gelu', help='activation') 87 | parser.add_argument('--output_attention', action='store_true', help='whether to output attention in ecoder') 88 | parser.add_argument('--do_predict', action='store_true', help='whether to predict unseen future data') 89 | parser.add_argument('--lamb', type=float, default=0.0) 90 | parser.add_argument('--individual', action='store_true', default=False, 91 | help='A linear layer for each variate(channel) individually') 92 | parser.add_argument('--pred_residual', action='store_true', default=False, 93 | help='Use PRREG strategy to train the model') 94 | parser.add_argument('--flat_input', action='store_true', default=False, 95 | help='flat the input variables in linear model. It is the CD strategy for Linear model.') 96 | parser.add_argument('--low_rank', action='store_true', default=False, 97 | help='low rank for linear layer for Linear model or Transformer layers') 98 | parser.add_argument('--rank_ratio', type=int, default=2, 99 | help='Rank reduction ratio for low rank model') 100 | # optimization 101 | parser.add_argument('--max_iter', type=int, default=1000, help='max iteration per epoch') 102 | parser.add_argument('--num_workers', type=int, default=10, help='data loader num workers') 103 | parser.add_argument('--itr', type=int, default=3, help='experiments times') 104 | parser.add_argument('--train_epochs', type=int, default=10, help='train epochs') 105 | parser.add_argument('--batch_size', type=int, default=32, help='batch size of train input data') 106 | parser.add_argument('--patience', type=int, default=3, help='early stopping patience') 107 | parser.add_argument('--learning_rate', type=float, default=0.0001, help='optimizer learning rate') 108 | parser.add_argument('--wd', type=float, default=0.0, help='weight decay') 109 | parser.add_argument('--des', type=str, default='test', help='exp description') 110 | parser.add_argument('--train_loss', type=str, default='mse', help='training loss function') 111 | parser.add_argument('--huber_beta', type=float, default=1.0, help='loss function') 112 | parser.add_argument('--lradj', type=str, default='type1', help='adjust learning rate') 113 | parser.add_argument('--use_amp', action='store_true', help='use automatic mixed precision training', default=False) 114 | 115 | # GPU 116 | parser.add_argument('--use_gpu', type=bool, default=True, help='use gpu') 117 | parser.add_argument('--gpu', type=int, default=0, help='gpu') 118 | parser.add_argument('--use_multi_gpu', action='store_true', help='use multiple gpus', default=False) 119 | parser.add_argument('--devices', type=str, default='0,1', help='device ids of multi gpus') 120 | 121 | args = parser.parse_args() 122 | 123 | args.ip_address = get_intern_ip_address() 124 | args.use_gpu = True if torch.cuda.is_available() and args.use_gpu else False 125 | 126 | if args.use_gpu and args.use_multi_gpu: 127 | args.dvices = args.devices.replace(' ', '') 128 | device_ids = args.devices.split(',') 129 | args.device_ids = [int(id_) for id_ in device_ids] 130 | args.gpu = args.device_ids[0] 131 | 132 | print('Args in experiment:') 133 | print(args) 134 | set_conv_type(args) 135 | if args.model == "gbrt": 136 | from exp.exp_GBRT import Exp_GBRT 137 | Exp = Exp_GBRT 138 | else: 139 | from exp.exp_main import Exp_Main 140 | Exp = Exp_Main 141 | if args.is_training: 142 | setting = '{}_{}_{}_ft{}_sl{}_ll{}_pl{}_dm{}_nh{}_el{}_dl{}_df{}_fc{}_eb{}_dt{}_{}'.format( 143 | args.task_id, 144 | args.model, 145 | args.data, 146 | args.features, 147 | args.seq_len, 148 | args.label_len, 149 | args.pred_len, 150 | args.d_model, 151 | args.n_heads, 152 | args.e_layers, 153 | args.d_layers, 154 | args.d_ff, 155 | args.factor, 156 | args.embed, 157 | args.distil, 158 | args.des) 159 | 160 | exp = Exp(args) # set experiments 161 | print('>>>>>>>start training : {}>>>>>>>>>>>>>>>>>>>>>>>>>>'.format(setting)) 162 | exp.train(setting) 163 | 164 | print('>>>>>>>testing : {}<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<'.format(setting)) 165 | exp.test(setting) 166 | 167 | torch.cuda.empty_cache() 168 | else: 169 | ii = 0 170 | setting = '{}_{}_{}_ft{}_sl{}_ll{}_pl{}_dm{}_nh{}_el{}_dl{}_df{}_fc{}_eb{}_dt{}_{}_{}'.format(args.model_id, 171 | args.model, 172 | args.data, 173 | args.features, 174 | args.seq_len, 175 | args.label_len, 176 | args.pred_len, 177 | args.d_model, 178 | args.n_heads, 179 | args.e_layers, 180 | args.d_layers, 181 | args.d_ff, 182 | args.factor, 183 | args.embed, 184 | args.distil, 185 | args.des, ii) 186 | 187 | exp = Exp(args) # set experiments 188 | print('>>>>>>>testing : {}<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<'.format(setting)) 189 | exp.test(setting, test=1) 190 | torch.cuda.empty_cache() 191 | 192 | 193 | if __name__ == "__main__": 194 | main() 195 | -------------------------------------------------------------------------------- /scripts/loss/Transformer_mae_mse.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=2 2 | 3 | #cd .. 4 | model=Transformer 5 | 6 | for t_loss in mae mse; do 7 | for preLen in 48; do 8 | 9 | # ETT m1 10 | python -u run.py \ 11 | --is_training 1 \ 12 | --data_path ETTm1.csv \ 13 | --task_id ETTm1 \ 14 | --model $model \ 15 | --data ETTm1 \ 16 | --features M \ 17 | --seq_len 96 \ 18 | --label_len 48 \ 19 | --pred_len $preLen \ 20 | --e_layers 2 \ 21 | --d_layers 1 \ 22 | --factor 3 \ 23 | --enc_in 7 \ 24 | --dec_in 7 \ 25 | --c_out 7 \ 26 | --des 'train valid loss type' \ 27 | --tags loss_type \ 28 | --train_loss $t_loss \ 29 | --d_model 512 30 | 31 | # ETTh1 32 | python -u run.py \ 33 | --is_training 1 \ 34 | --data_path ETTh1.csv \ 35 | --task_id ETTh1 \ 36 | --model $model \ 37 | --data ETTh1 \ 38 | --features M \ 39 | --seq_len 96 \ 40 | --label_len 48 \ 41 | --pred_len $preLen \ 42 | --e_layers 2 \ 43 | --d_layers 1 \ 44 | --factor 3 \ 45 | --enc_in 7 \ 46 | --dec_in 7 \ 47 | --c_out 7 \ 48 | --des 'train valid loss type' \ 49 | --tags loss_type \ 50 | --train_loss $t_loss \ 51 | --d_model 512 52 | 53 | # ETTm2 54 | python -u run.py \ 55 | --is_training 1 \ 56 | --data_path ETTm2.csv \ 57 | --task_id ETTm2 \ 58 | --model $model \ 59 | --data ETTm2 \ 60 | --features M \ 61 | --seq_len 96 \ 62 | --label_len 48 \ 63 | --pred_len $preLen \ 64 | --e_layers 2 \ 65 | --d_layers 1 \ 66 | --factor 3 \ 67 | --enc_in 7 \ 68 | --dec_in 7 \ 69 | --c_out 7 \ 70 | --des 'train valid loss type' \ 71 | --tags loss_type \ 72 | --train_loss $t_loss \ 73 | --d_model 512 74 | 75 | # ETTh2 76 | python -u run.py \ 77 | --is_training 1 \ 78 | --data_path ETTh2.csv \ 79 | --task_id ETTh2 \ 80 | --model $model \ 81 | --data ETTh2 \ 82 | --features M \ 83 | --seq_len 96 \ 84 | --label_len 48 \ 85 | --pred_len $preLen \ 86 | --e_layers 2 \ 87 | --d_layers 1 \ 88 | --factor 3 \ 89 | --enc_in 7 \ 90 | --dec_in 7 \ 91 | --c_out 7 \ 92 | --des 'train valid loss type' \ 93 | --tags loss_type \ 94 | --train_loss $t_loss \ 95 | --d_model 512 96 | 97 | ## electricity 98 | python -u run.py \ 99 | --is_training 1 \ 100 | --data_path electricity.csv \ 101 | --task_id ECL \ 102 | --model $model \ 103 | --data custom \ 104 | --features M \ 105 | --seq_len 96 \ 106 | --label_len 48 \ 107 | --pred_len $preLen \ 108 | --e_layers 2 \ 109 | --d_layers 1 \ 110 | --factor 3 \ 111 | --enc_in 321 \ 112 | --dec_in 321 \ 113 | --c_out 321 \ 114 | --des 'train valid loss type' \ 115 | --tags loss_type \ 116 | --train_loss $t_loss 117 | 118 | # exchange 119 | python -u run.py \ 120 | --is_training 1 \ 121 | --data_path exchange_rate.csv \ 122 | --task_id Exchange \ 123 | --model $model \ 124 | --data custom \ 125 | --features M \ 126 | --seq_len 96 \ 127 | --label_len 48 \ 128 | --pred_len $preLen \ 129 | --e_layers 2 \ 130 | --d_layers 1 \ 131 | --factor 3 \ 132 | --enc_in 8 \ 133 | --dec_in 8 \ 134 | --c_out 8 \ 135 | --des 'train valid loss type' \ 136 | --tags loss_type \ 137 | --train_loss $t_loss 138 | 139 | # traffic 140 | python -u run.py \ 141 | --is_training 1 \ 142 | --data_path traffic.csv \ 143 | --task_id traffic \ 144 | --model $model \ 145 | --data custom \ 146 | --features M \ 147 | --seq_len 96 \ 148 | --label_len 48 \ 149 | --pred_len $preLen \ 150 | --e_layers 2 \ 151 | --d_layers 1 \ 152 | --factor 3 \ 153 | --enc_in 862 \ 154 | --dec_in 862 \ 155 | --c_out 862 \ 156 | --des 'train valid loss type' \ 157 | --tags loss_type \ 158 | --train_loss $t_loss 159 | 160 | # weather 161 | python -u run.py \ 162 | --is_training 1 \ 163 | --data_path weather.csv \ 164 | --task_id weather \ 165 | --model $model \ 166 | --data custom \ 167 | --features M \ 168 | --seq_len 96 \ 169 | --label_len 48 \ 170 | --pred_len $preLen \ 171 | --e_layers 2 \ 172 | --d_layers 1 \ 173 | --factor 3 \ 174 | --enc_in 21 \ 175 | --dec_in 21 \ 176 | --c_out 21 \ 177 | --des 'train valid loss type' \ 178 | --tags loss_type \ 179 | --train_loss $t_loss 180 | done 181 | 182 | for preLen in 24; do 183 | # illness 184 | python -u run.py \ 185 | --is_training 1 \ 186 | --data_path national_illness.csv \ 187 | --task_id ili \ 188 | --model $model \ 189 | --data custom \ 190 | --features M \ 191 | --seq_len 36 \ 192 | --label_len 18 \ 193 | --pred_len $preLen \ 194 | --e_layers 2 \ 195 | --d_layers 1 \ 196 | --factor 3 \ 197 | --enc_in 7 \ 198 | --dec_in 7 \ 199 | --c_out 7 \ 200 | --des 'train valid loss type' \ 201 | --tags loss_type \ 202 | --train_loss $t_loss 203 | done 204 | done 205 | -------------------------------------------------------------------------------- /scripts/low_rank/Transformer.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=1 2 | 3 | #cd .. 4 | model=Transformer 5 | for r in 1 2 4 8 16 32 64 128 256 512; do 6 | for preLen in 48; do 7 | # ETT m1 8 | python -u run.py \ 9 | --is_training 1 \ 10 | --data_path ETTm1.csv \ 11 | --task_id ETTm1 \ 12 | --model $model \ 13 | --data ETTm1 \ 14 | --features M \ 15 | --seq_len 96 \ 16 | --label_len 48 \ 17 | --pred_len $preLen \ 18 | --e_layers 2 \ 19 | --d_layers 1 \ 20 | --factor 3 \ 21 | --enc_in 7 \ 22 | --dec_in 7 \ 23 | --c_out 7 \ 24 | --des 'low rank experiment' \ 25 | --tags low_rank \ 26 | --low_rank \ 27 | --rank_ratio $r \ 28 | --d_model 512 29 | 30 | # ETTh1 31 | python -u run.py \ 32 | --is_training 1 \ 33 | --data_path ETTh1.csv \ 34 | --task_id ETTh1 \ 35 | --model $model \ 36 | --data ETTh1 \ 37 | --features M \ 38 | --seq_len 96 \ 39 | --label_len 48 \ 40 | --pred_len $preLen \ 41 | --e_layers 2 \ 42 | --d_layers 1 \ 43 | --factor 3 \ 44 | --enc_in 7 \ 45 | --dec_in 7 \ 46 | --c_out 7 \ 47 | --des 'low rank experiment' \ 48 | --tags low_rank \ 49 | --low_rank \ 50 | --rank_ratio $r \ 51 | --d_model 512 52 | 53 | # ETTm2 54 | python -u run.py \ 55 | --is_training 1 \ 56 | --data_path ETTm2.csv \ 57 | --task_id ETTm2 \ 58 | --model $model \ 59 | --data ETTm2 \ 60 | --features M \ 61 | --seq_len 96 \ 62 | --label_len 48 \ 63 | --pred_len $preLen \ 64 | --e_layers 2 \ 65 | --d_layers 1 \ 66 | --factor 3 \ 67 | --enc_in 7 \ 68 | --dec_in 7 \ 69 | --c_out 7 \ 70 | --des 'low rank experiment' \ 71 | --tags low_rank \ 72 | --low_rank \ 73 | --rank_ratio $r \ 74 | --d_model 512 75 | 76 | # ETTh2 77 | python -u run.py \ 78 | --is_training 1 \ 79 | --data_path ETTh2.csv \ 80 | --task_id ETTh2 \ 81 | --model $model \ 82 | --data ETTh2 \ 83 | --features M \ 84 | --seq_len 96 \ 85 | --label_len 48 \ 86 | --pred_len $preLen \ 87 | --e_layers 2 \ 88 | --d_layers 1 \ 89 | --factor 3 \ 90 | --enc_in 7 \ 91 | --dec_in 7 \ 92 | --c_out 7 \ 93 | --des 'low rank experiment' \ 94 | --tags low_rank \ 95 | --low_rank \ 96 | --rank_ratio $r \ 97 | --d_model 512 98 | 99 | ## electricity 100 | python -u run.py \ 101 | --is_training 1 \ 102 | --data_path electricity.csv \ 103 | --task_id ECL \ 104 | --model $model \ 105 | --data custom \ 106 | --features M \ 107 | --seq_len 96 \ 108 | --label_len 48 \ 109 | --pred_len $preLen \ 110 | --e_layers 2 \ 111 | --d_layers 1 \ 112 | --factor 3 \ 113 | --enc_in 321 \ 114 | --dec_in 321 \ 115 | --c_out 321 \ 116 | --des 'low rank experiment' \ 117 | --tags low_rank \ 118 | --low_rank \ 119 | --rank_ratio $r 120 | 121 | # exchange 122 | python -u run.py \ 123 | --is_training 1 \ 124 | --data_path exchange_rate.csv \ 125 | --task_id Exchange \ 126 | --model $model \ 127 | --data custom \ 128 | --features M \ 129 | --seq_len 96 \ 130 | --label_len 48 \ 131 | --pred_len $preLen \ 132 | --e_layers 2 \ 133 | --d_layers 1 \ 134 | --factor 3 \ 135 | --enc_in 8 \ 136 | --dec_in 8 \ 137 | --c_out 8 \ 138 | --des 'low rank experiment' \ 139 | --tags low_rank \ 140 | --low_rank \ 141 | --rank_ratio $r 142 | 143 | # traffic 144 | python -u run.py \ 145 | --is_training 1 \ 146 | --data_path traffic.csv \ 147 | --task_id traffic \ 148 | --model $model \ 149 | --data custom \ 150 | --features M \ 151 | --seq_len 96 \ 152 | --label_len 48 \ 153 | --pred_len $preLen \ 154 | --e_layers 2 \ 155 | --d_layers 1 \ 156 | --factor 3 \ 157 | --enc_in 862 \ 158 | --dec_in 862 \ 159 | --c_out 862 \ 160 | --des 'low rank experiment' \ 161 | --tags low_rank \ 162 | --low_rank \ 163 | --rank_ratio $r 164 | 165 | # weather 166 | python -u run.py \ 167 | --is_training 1 \ 168 | --data_path weather.csv \ 169 | --task_id weather \ 170 | --model $model \ 171 | --data custom \ 172 | --features M \ 173 | --seq_len 96 \ 174 | --label_len 48 \ 175 | --pred_len $preLen \ 176 | --e_layers 2 \ 177 | --d_layers 1 \ 178 | --factor 3 \ 179 | --enc_in 21 \ 180 | --dec_in 21 \ 181 | --c_out 21 \ 182 | --des 'low rank experiment' \ 183 | --tags low_rank \ 184 | --low_rank \ 185 | --rank_ratio $r 186 | done 187 | 188 | for preLen in 24 36; do 189 | # illness 190 | python -u run.py \ 191 | --is_training 1 \ 192 | --data_path national_illness.csv \ 193 | --task_id ili \ 194 | --model $model \ 195 | --data custom \ 196 | --features M \ 197 | --seq_len 36 \ 198 | --label_len 18 \ 199 | --pred_len $preLen \ 200 | --e_layers 2 \ 201 | --d_layers 1 \ 202 | --factor 3 \ 203 | --enc_in 7 \ 204 | --dec_in 7 \ 205 | --c_out 7 \ 206 | --des 'low rank experiment' \ 207 | --tags low_rank \ 208 | --low_rank \ 209 | --rank_ratio $r 210 | done 211 | done 212 | -------------------------------------------------------------------------------- /scripts/performance/channel_dependent/DeepVAR.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=2 2 | 3 | #cd .. 4 | model=DeepVAR 5 | 6 | #for preLen in 96 192; do 7 | for preLen in 48 96; do 8 | 9 | # ETT m1 10 | python -u run.py \ 11 | --is_training 1 \ 12 | --data_path ETTm1.csv \ 13 | --task_id ETTm1 \ 14 | --model $model \ 15 | --data ETTm1 \ 16 | --features M \ 17 | --seq_len 96 \ 18 | --label_len 48 \ 19 | --pred_len $preLen \ 20 | --e_layers 2 \ 21 | --d_layers 1 \ 22 | --factor 3 \ 23 | --enc_in 7 \ 24 | --dec_in 7 \ 25 | --c_out 7 \ 26 | --des 'Exp' \ 27 | --d_model 512 28 | 29 | # ETTh1 30 | python -u run.py \ 31 | --is_training 1 \ 32 | --data_path ETTh1.csv \ 33 | --task_id ETTh1 \ 34 | --model $model \ 35 | --data ETTh1 \ 36 | --features M \ 37 | --seq_len 96 \ 38 | --label_len 48 \ 39 | --pred_len $preLen \ 40 | --e_layers 2 \ 41 | --d_layers 1 \ 42 | --factor 3 \ 43 | --enc_in 7 \ 44 | --dec_in 7 \ 45 | --c_out 7 \ 46 | --des 'Exp' \ 47 | --d_model 512 48 | 49 | # ETTm2 50 | python -u run.py \ 51 | --is_training 1 \ 52 | --data_path ETTm2.csv \ 53 | --task_id ETTm2 \ 54 | --model $model \ 55 | --data ETTm2 \ 56 | --features M \ 57 | --seq_len 96 \ 58 | --label_len 48 \ 59 | --pred_len $preLen \ 60 | --e_layers 2 \ 61 | --d_layers 1 \ 62 | --factor 3 \ 63 | --enc_in 7 \ 64 | --dec_in 7 \ 65 | --c_out 7 \ 66 | --des 'Exp' \ 67 | --d_model 512 68 | 69 | # ETTh2 70 | python -u run.py \ 71 | --is_training 1 \ 72 | --data_path ETTh2.csv \ 73 | --task_id ETTh2 \ 74 | --model $model \ 75 | --data ETTh2 \ 76 | --features M \ 77 | --seq_len 96 \ 78 | --label_len 48 \ 79 | --pred_len $preLen \ 80 | --e_layers 2 \ 81 | --d_layers 1 \ 82 | --factor 3 \ 83 | --enc_in 7 \ 84 | --dec_in 7 \ 85 | --c_out 7 \ 86 | --des 'Exp' \ 87 | --d_model 512 88 | 89 | ## electricity 90 | python -u run.py \ 91 | --is_training 1 \ 92 | --data_path electricity.csv \ 93 | --task_id ECL \ 94 | --model $model \ 95 | --data custom \ 96 | --features M \ 97 | --seq_len 96 \ 98 | --label_len 48 \ 99 | --pred_len $preLen \ 100 | --e_layers 2 \ 101 | --d_layers 1 \ 102 | --factor 3 \ 103 | --enc_in 321 \ 104 | --dec_in 321 \ 105 | --c_out 321 \ 106 | --des 'Exp' 107 | 108 | # exchange 109 | python -u run.py \ 110 | --is_training 1 \ 111 | --data_path exchange_rate.csv \ 112 | --task_id Exchange \ 113 | --model $model \ 114 | --data custom \ 115 | --features M \ 116 | --seq_len 96 \ 117 | --label_len 48 \ 118 | --pred_len $preLen \ 119 | --e_layers 2 \ 120 | --d_layers 1 \ 121 | --factor 3 \ 122 | --enc_in 8 \ 123 | --dec_in 8 \ 124 | --c_out 8 \ 125 | --des 'Exp' 126 | 127 | # traffic 128 | python -u run.py \ 129 | --is_training 1 \ 130 | --data_path traffic.csv \ 131 | --task_id traffic \ 132 | --model $model \ 133 | --data custom \ 134 | --features M \ 135 | --seq_len 96 \ 136 | --label_len 48 \ 137 | --pred_len $preLen \ 138 | --e_layers 2 \ 139 | --d_layers 1 \ 140 | --factor 3 \ 141 | --enc_in 862 \ 142 | --dec_in 862 \ 143 | --c_out 862 \ 144 | --des 'Exp' 145 | 146 | # weather 147 | python -u run.py \ 148 | --is_training 1 \ 149 | --data_path weather.csv \ 150 | --task_id weather \ 151 | --model $model \ 152 | --data custom \ 153 | --features M \ 154 | --seq_len 96 \ 155 | --label_len 48 \ 156 | --pred_len $preLen \ 157 | --e_layers 2 \ 158 | --d_layers 1 \ 159 | --factor 3 \ 160 | --enc_in 21 \ 161 | --dec_in 21 \ 162 | --c_out 21 \ 163 | --des 'Exp' 164 | done 165 | 166 | for preLen in 24 36; do 167 | # illness 168 | python -u run.py \ 169 | --is_training 1 \ 170 | --data_path national_illness.csv \ 171 | --task_id ili \ 172 | --model $model \ 173 | --data custom \ 174 | --features M \ 175 | --seq_len 36 \ 176 | --label_len 18 \ 177 | --pred_len $preLen \ 178 | --e_layers 2 \ 179 | --d_layers 1 \ 180 | --factor 3 \ 181 | --enc_in 7 \ 182 | --dec_in 7 \ 183 | --c_out 7 \ 184 | --des 'Exp' 185 | done 186 | -------------------------------------------------------------------------------- /scripts/performance/channel_dependent/GBRT.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=0 2 | model_name=gbrt 3 | for pred_len in 48 96; do 4 | seq_len=96 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'Baseline' \ 16 | --batch_size 32 --learning_rate 0.005 17 | 18 | python -u run.py \ 19 | --is_training 1 \ 20 | --data_path ETTh2.csv \ 21 | --task_id ETTh2_$seq_len'_'$pred_len \ 22 | --model $model_name \ 23 | --data ETTh2 \ 24 | --features M \ 25 | --seq_len $seq_len \ 26 | --pred_len $pred_len \ 27 | --enc_in 7 \ 28 | --des 'Baseline' \ 29 | --batch_size 32 --learning_rate 0.05 30 | 31 | python -u run.py \ 32 | --is_training 1 \ 33 | --data_path ETTm1.csv \ 34 | --task_id ETTm1_$seq_len'_'$pred_len \ 35 | --model $model_name \ 36 | --data ETTm1 \ 37 | --features M \ 38 | --seq_len $seq_len \ 39 | --pred_len $pred_len \ 40 | --enc_in 7 \ 41 | --des 'Baseline' \ 42 | --batch_size 8 --learning_rate 0.0001 43 | 44 | python -u run.py \ 45 | --is_training 1 \ 46 | --data_path ETTm2.csv \ 47 | --task_id ETTm2_$seq_len'_'$pred_len \ 48 | --model $model_name \ 49 | --data ETTm2 \ 50 | --features M \ 51 | --seq_len $seq_len \ 52 | --pred_len $pred_len \ 53 | --enc_in 7 \ 54 | --des 'Baseline' \ 55 | --batch_size 32 --learning_rate 0.001 56 | 57 | python -u run.py \ 58 | --is_training 1 \ 59 | --data_path exchange_rate.csv \ 60 | --task_id Exchange_$seq_len'_'$pred_len \ 61 | --model $model_name \ 62 | --data custom \ 63 | --features M \ 64 | --seq_len $seq_len \ 65 | --pred_len $pred_len \ 66 | --enc_in 8 \ 67 | --des 'Baseline' \ 68 | --batch_size 32 --learning_rate 0.0005 69 | 70 | python -u run.py \ 71 | --is_training 1 \ 72 | --data_path weather.csv \ 73 | --task_id weather_$seq_len'_'$pred_len \ 74 | --model $model_name \ 75 | --data custom \ 76 | --features M \ 77 | --seq_len $seq_len \ 78 | --pred_len $pred_len \ 79 | --enc_in 21 \ 80 | --des 'Baseline' \ 81 | --batch_size 32 82 | 83 | python -u run.py \ 84 | --is_training 1 \ 85 | --data_path traffic.csv \ 86 | --task_id traffic_$seq_len'_'$pred_len \ 87 | --model $model_name \ 88 | --data custom \ 89 | --features M \ 90 | --seq_len $seq_len \ 91 | --pred_len $pred_len \ 92 | --enc_in 862 \ 93 | --des 'Baseline' \ 94 | --learning_rate 0.05 95 | 96 | python -u run.py \ 97 | --is_training 1 \ 98 | --data_path electricity.csv \ 99 | --task_id Electricity_$seq_len'_'$pred_len \ 100 | --model $model_name \ 101 | --data custom \ 102 | --features M \ 103 | --seq_len $seq_len \ 104 | --pred_len $pred_len \ 105 | --enc_in 321 \ 106 | --des 'Baseline' \ 107 | --learning_rate 0.001 108 | done 109 | 110 | for pred_len in 24 36; do 111 | seq_len=36 112 | python -u run.py \ 113 | --is_training 1 \ 114 | --data_path national_illness.csv \ 115 | --task_id national_illness_$seq_len'_'$pred_len \ 116 | --model $model_name \ 117 | --data custom \ 118 | --features M \ 119 | --seq_len $seq_len \ 120 | --label_len 18 \ 121 | --pred_len $pred_len \ 122 | --enc_in 7 \ 123 | --des 'Baseline' \ 124 | --batch_size 32 --learning_rate 0.01 125 | done 126 | -------------------------------------------------------------------------------- /scripts/performance/channel_dependent/Informer.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=3 2 | 3 | #cd .. 4 | model=Informer 5 | 6 | for preLen in 48 96; do 7 | 8 | # ETT m1 9 | python -u run.py \ 10 | --is_training 1 \ 11 | --data_path ETTm1.csv \ 12 | --task_id ETTm1 \ 13 | --model $model \ 14 | --data ETTm1 \ 15 | --features M \ 16 | --seq_len 96 \ 17 | --label_len 48 \ 18 | --pred_len $preLen \ 19 | --e_layers 2 \ 20 | --d_layers 1 \ 21 | --factor 3 \ 22 | --enc_in 7 \ 23 | --dec_in 7 \ 24 | --c_out 7 \ 25 | --des 'Exp' \ 26 | --d_model 512 27 | 28 | # ETTh1 29 | python -u run.py \ 30 | --is_training 1 \ 31 | --data_path ETTh1.csv \ 32 | --task_id ETTh1 \ 33 | --model $model \ 34 | --data ETTh1 \ 35 | --features M \ 36 | --seq_len 96 \ 37 | --label_len 48 \ 38 | --pred_len $preLen \ 39 | --e_layers 2 \ 40 | --d_layers 1 \ 41 | --factor 3 \ 42 | --enc_in 7 \ 43 | --dec_in 7 \ 44 | --c_out 7 \ 45 | --des 'Exp' \ 46 | --d_model 512 47 | 48 | # ETTm2 49 | python -u run.py \ 50 | --is_training 1 \ 51 | --data_path ETTm2.csv \ 52 | --task_id ETTm2 \ 53 | --model $model \ 54 | --data ETTm2 \ 55 | --features M \ 56 | --seq_len 96 \ 57 | --label_len 48 \ 58 | --pred_len $preLen \ 59 | --e_layers 2 \ 60 | --d_layers 1 \ 61 | --factor 3 \ 62 | --enc_in 7 \ 63 | --dec_in 7 \ 64 | --c_out 7 \ 65 | --des 'Exp' \ 66 | --d_model 512 67 | 68 | # ETTh2 69 | python -u run.py \ 70 | --is_training 1 \ 71 | --data_path ETTh2.csv \ 72 | --task_id ETTh2 \ 73 | --model $model \ 74 | --data ETTh2 \ 75 | --features M \ 76 | --seq_len 96 \ 77 | --label_len 48 \ 78 | --pred_len $preLen \ 79 | --e_layers 2 \ 80 | --d_layers 1 \ 81 | --factor 3 \ 82 | --enc_in 7 \ 83 | --dec_in 7 \ 84 | --c_out 7 \ 85 | --des 'Exp' \ 86 | --d_model 512 87 | 88 | ## electricity 89 | python -u run.py \ 90 | --is_training 1 \ 91 | --data_path electricity.csv \ 92 | --task_id ECL \ 93 | --model $model \ 94 | --data custom \ 95 | --features M \ 96 | --seq_len 96 \ 97 | --label_len 48 \ 98 | --pred_len $preLen \ 99 | --e_layers 2 \ 100 | --d_layers 1 \ 101 | --factor 3 \ 102 | --enc_in 321 \ 103 | --dec_in 321 \ 104 | --c_out 321 \ 105 | --des 'Exp' 106 | 107 | # exchange 108 | python -u run.py \ 109 | --is_training 1 \ 110 | --data_path exchange_rate.csv \ 111 | --task_id Exchange \ 112 | --model $model \ 113 | --data custom \ 114 | --features M \ 115 | --seq_len 96 \ 116 | --label_len 48 \ 117 | --pred_len $preLen \ 118 | --e_layers 2 \ 119 | --d_layers 1 \ 120 | --factor 3 \ 121 | --enc_in 8 \ 122 | --dec_in 8 \ 123 | --c_out 8 \ 124 | --des 'Exp' 125 | 126 | # traffic 127 | python -u run.py \ 128 | --is_training 1 \ 129 | --data_path traffic.csv \ 130 | --task_id traffic \ 131 | --model $model \ 132 | --data custom \ 133 | --features M \ 134 | --seq_len 96 \ 135 | --label_len 48 \ 136 | --pred_len $preLen \ 137 | --e_layers 2 \ 138 | --d_layers 1 \ 139 | --factor 3 \ 140 | --enc_in 862 \ 141 | --dec_in 862 \ 142 | --c_out 862 \ 143 | --des 'Exp' 144 | 145 | # weather 146 | python -u run.py \ 147 | --is_training 1 \ 148 | --data_path weather.csv \ 149 | --task_id weather \ 150 | --model $model \ 151 | --data custom \ 152 | --features M \ 153 | --seq_len 96 \ 154 | --label_len 48 \ 155 | --pred_len $preLen \ 156 | --e_layers 2 \ 157 | --d_layers 1 \ 158 | --factor 3 \ 159 | --enc_in 21 \ 160 | --dec_in 21 \ 161 | --c_out 21 \ 162 | --des 'Exp' 163 | done 164 | 165 | for preLen in 24 36; do 166 | # illness 167 | python -u run.py \ 168 | --is_training 1 \ 169 | --data_path national_illness.csv \ 170 | --task_id ili \ 171 | --model $model \ 172 | --data custom \ 173 | --features M \ 174 | --seq_len 36 \ 175 | --label_len 18 \ 176 | --pred_len $preLen \ 177 | --e_layers 2 \ 178 | --d_layers 1 \ 179 | --factor 3 \ 180 | --enc_in 7 \ 181 | --dec_in 7 \ 182 | --c_out 7 \ 183 | --des 'Exp' 184 | done 185 | -------------------------------------------------------------------------------- /scripts/performance/channel_dependent/Linear.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=0 2 | model_name=Linear 3 | for pred_len in 48; do 4 | seq_len=96 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'Baseline' \ 16 | --flat_input \ 17 | --batch_size 32 --learning_rate 0.005 18 | 19 | python -u run.py \ 20 | --is_training 1 \ 21 | --data_path ETTh2.csv \ 22 | --task_id ETTh2_$seq_len'_'$pred_len \ 23 | --model $model_name \ 24 | --data ETTh2 \ 25 | --features M \ 26 | --seq_len $seq_len \ 27 | --pred_len $pred_len \ 28 | --enc_in 7 \ 29 | --des 'Baseline' \ 30 | --flat_input \ 31 | --batch_size 32 --learning_rate 0.05 32 | 33 | python -u run.py \ 34 | --is_training 1 \ 35 | --data_path ETTm1.csv \ 36 | --task_id ETTm1_$seq_len'_'$pred_len \ 37 | --model $model_name \ 38 | --data ETTm1 \ 39 | --features M \ 40 | --seq_len $seq_len \ 41 | --pred_len $pred_len \ 42 | --enc_in 7 \ 43 | --des 'Baseline' \ 44 | --flat_input \ 45 | --batch_size 8 --learning_rate 0.0001 46 | 47 | python -u run.py \ 48 | --is_training 1 \ 49 | --data_path ETTm2.csv \ 50 | --task_id ETTm2_$seq_len'_'$pred_len \ 51 | --model $model_name \ 52 | --data ETTm2 \ 53 | --features M \ 54 | --seq_len $seq_len \ 55 | --pred_len $pred_len \ 56 | --enc_in 7 \ 57 | --des 'Baseline' \ 58 | --flat_input \ 59 | --batch_size 32 --learning_rate 0.001 60 | 61 | python -u run.py \ 62 | --is_training 1 \ 63 | --data_path exchange_rate.csv \ 64 | --task_id Exchange_$seq_len'_'$pred_len \ 65 | --model $model_name \ 66 | --data custom \ 67 | --features M \ 68 | --seq_len $seq_len \ 69 | --pred_len $pred_len \ 70 | --enc_in 8 \ 71 | --des 'Baseline' \ 72 | --flat_input \ 73 | --batch_size 32 --learning_rate 0.0005 74 | 75 | python -u run.py \ 76 | --is_training 1 \ 77 | --data_path weather.csv \ 78 | --task_id weather_$seq_len'_'$pred_len \ 79 | --model $model_name \ 80 | --data custom \ 81 | --features M \ 82 | --seq_len $seq_len \ 83 | --pred_len $pred_len \ 84 | --enc_in 21 \ 85 | --des 'Baseline' \ 86 | --flat_input \ 87 | --batch_size 32 88 | 89 | python -u run.py \ 90 | --is_training 1 \ 91 | --data_path traffic.csv \ 92 | --task_id traffic_$seq_len'_'$pred_len \ 93 | --model $model_name \ 94 | --data custom \ 95 | --features M \ 96 | --seq_len $seq_len \ 97 | --pred_len $pred_len \ 98 | --enc_in 862 \ 99 | --des 'Baseline' \ 100 | --flat_input \ 101 | --learning_rate 0.05 102 | 103 | python -u run.py \ 104 | --is_training 1 \ 105 | --data_path electricity.csv \ 106 | --task_id Electricity_$seq_len'_'$pred_len \ 107 | --model $model_name \ 108 | --data custom \ 109 | --features M \ 110 | --seq_len $seq_len \ 111 | --pred_len $pred_len \ 112 | --enc_in 321 \ 113 | --des 'Baseline' \ 114 | --flat_input \ 115 | --learning_rate 0.001 116 | done 117 | 118 | python -u run.py \ 119 | --is_training 1 \ 120 | --data_path electricity.csv \ 121 | --task_id Electricity_96_48 \ 122 | --model Linear \ 123 | --data custom \ 124 | --features M \ 125 | --seq_len 96 \ 126 | --pred_len 48 \ 127 | --enc_in 321 \ 128 | --des 'Baseline' \ 129 | --flat_input \ 130 | --learning_rate 0.001 131 | 132 | #for pred_len in 24 36 48 60; do 133 | # seq_len=36 134 | # python -u run.py \ 135 | # --is_training 1 \ 136 | # --data_path national_illness.csv \ 137 | # --task_id national_illness_$seq_len'_'$pred_len \ 138 | # --model $model_name \ 139 | # --data custom \ 140 | # --features M \ 141 | # --seq_len $seq_len \ 142 | # --label_len 18 \ 143 | # --pred_len $pred_len \ 144 | # --enc_in 7 \ 145 | # --des 'Noscale' \ 146 | # --no_scale \ 147 | # --batch_size 32 --learning_rate 0.01 148 | #done 149 | -------------------------------------------------------------------------------- /scripts/performance/channel_dependent/MLP.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=0 2 | model_name=MLP 3 | for pred_len in 48 96; do 4 | seq_len=96 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'Baseline' \ 16 | --batch_size 32 --learning_rate 0.005 17 | 18 | python -u run.py \ 19 | --is_training 1 \ 20 | --data_path ETTh2.csv \ 21 | --task_id ETTh2_$seq_len'_'$pred_len \ 22 | --model $model_name \ 23 | --data ETTh2 \ 24 | --features M \ 25 | --seq_len $seq_len \ 26 | --pred_len $pred_len \ 27 | --enc_in 7 \ 28 | --des 'Baseline' \ 29 | --batch_size 32 --learning_rate 0.05 30 | 31 | python -u run.py \ 32 | --is_training 1 \ 33 | --data_path ETTm1.csv \ 34 | --task_id ETTm1_$seq_len'_'$pred_len \ 35 | --model $model_name \ 36 | --data ETTm1 \ 37 | --features M \ 38 | --seq_len $seq_len \ 39 | --pred_len $pred_len \ 40 | --enc_in 7 \ 41 | --des 'Baseline' \ 42 | --batch_size 8 --learning_rate 0.0001 43 | 44 | python -u run.py \ 45 | --is_training 1 \ 46 | --data_path ETTm2.csv \ 47 | --task_id ETTm2_$seq_len'_'$pred_len \ 48 | --model $model_name \ 49 | --data ETTm2 \ 50 | --features M \ 51 | --seq_len $seq_len \ 52 | --pred_len $pred_len \ 53 | --enc_in 7 \ 54 | --des 'Baseline' \ 55 | --batch_size 32 --learning_rate 0.001 56 | 57 | python -u run.py \ 58 | --is_training 1 \ 59 | --data_path exchange_rate.csv \ 60 | --task_id Exchange_$seq_len'_'$pred_len \ 61 | --model $model_name \ 62 | --data custom \ 63 | --features M \ 64 | --seq_len $seq_len \ 65 | --pred_len $pred_len \ 66 | --enc_in 8 \ 67 | --des 'Baseline' \ 68 | --batch_size 32 --learning_rate 0.0005 69 | 70 | python -u run.py \ 71 | --is_training 1 \ 72 | --data_path weather.csv \ 73 | --task_id weather_$seq_len'_'$pred_len \ 74 | --model $model_name \ 75 | --data custom \ 76 | --features M \ 77 | --seq_len $seq_len \ 78 | --pred_len $pred_len \ 79 | --enc_in 21 \ 80 | --des 'Baseline' \ 81 | --batch_size 32 82 | 83 | python -u run.py \ 84 | --is_training 1 \ 85 | --data_path traffic.csv \ 86 | --task_id traffic_$seq_len'_'$pred_len \ 87 | --model $model_name \ 88 | --data custom \ 89 | --features M \ 90 | --seq_len $seq_len \ 91 | --pred_len $pred_len \ 92 | --enc_in 862 \ 93 | --des 'Baseline' \ 94 | --learning_rate 0.05 95 | 96 | python -u run.py \ 97 | --is_training 1 \ 98 | --data_path electricity.csv \ 99 | --task_id Electricity_$seq_len'_'$pred_len \ 100 | --model $model_name \ 101 | --data custom \ 102 | --features M \ 103 | --seq_len $seq_len \ 104 | --pred_len $pred_len \ 105 | --enc_in 321 \ 106 | --des 'Baseline' \ 107 | --learning_rate 0.001 108 | done 109 | for pred_len in 24 36; do 110 | seq_len=36 111 | python -u run.py \ 112 | --is_training 1 \ 113 | --data_path national_illness.csv \ 114 | --task_id national_illness_$seq_len'_'$pred_len \ 115 | --model $model_name \ 116 | --data custom \ 117 | --features M \ 118 | --seq_len $seq_len \ 119 | --label_len 18 \ 120 | --pred_len $pred_len \ 121 | --enc_in 7 \ 122 | --des 'Baseline' \ 123 | --batch_size 32 --learning_rate 0.01 124 | done 125 | -------------------------------------------------------------------------------- /scripts/performance/channel_dependent/TCN.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=2 2 | model_name=TCN 3 | for pred_len in 48 96; do 4 | seq_len=96 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'Baseline' \ 16 | --batch_size 32 --learning_rate 0.005 17 | 18 | python -u run.py \ 19 | --is_training 1 \ 20 | --data_path ETTh2.csv \ 21 | --task_id ETTh2_$seq_len'_'$pred_len \ 22 | --model $model_name \ 23 | --data ETTh2 \ 24 | --features M \ 25 | --seq_len $seq_len \ 26 | --pred_len $pred_len \ 27 | --enc_in 7 \ 28 | --des 'Baseline' \ 29 | --batch_size 32 --learning_rate 0.05 30 | 31 | python -u run.py \ 32 | --is_training 1 \ 33 | --data_path ETTm1.csv \ 34 | --task_id ETTm1_$seq_len'_'$pred_len \ 35 | --model $model_name \ 36 | --data ETTm1 \ 37 | --features M \ 38 | --seq_len $seq_len \ 39 | --pred_len $pred_len \ 40 | --enc_in 7 \ 41 | --des 'Baseline' \ 42 | --batch_size 8 --learning_rate 0.0001 43 | 44 | python -u run.py \ 45 | --is_training 1 \ 46 | --data_path ETTm2.csv \ 47 | --task_id ETTm2_$seq_len'_'$pred_len \ 48 | --model $model_name \ 49 | --data ETTm2 \ 50 | --features M \ 51 | --seq_len $seq_len \ 52 | --pred_len $pred_len \ 53 | --enc_in 7 \ 54 | --des 'Baseline' \ 55 | --batch_size 32 --learning_rate 0.001 56 | 57 | python -u run.py \ 58 | --is_training 1 \ 59 | --data_path exchange_rate.csv \ 60 | --task_id Exchange_$seq_len'_'$pred_len \ 61 | --model $model_name \ 62 | --data custom \ 63 | --features M \ 64 | --seq_len $seq_len \ 65 | --pred_len $pred_len \ 66 | --enc_in 8 \ 67 | --des 'Baseline' \ 68 | --batch_size 32 --learning_rate 0.0005 69 | 70 | python -u run.py \ 71 | --is_training 1 \ 72 | --data_path weather.csv \ 73 | --task_id weather_$seq_len'_'$pred_len \ 74 | --model $model_name \ 75 | --data custom \ 76 | --features M \ 77 | --seq_len $seq_len \ 78 | --pred_len $pred_len \ 79 | --enc_in 21 \ 80 | --des 'Baseline' \ 81 | --batch_size 32 82 | 83 | python -u run.py \ 84 | --is_training 1 \ 85 | --data_path traffic.csv \ 86 | --task_id traffic_$seq_len'_'$pred_len \ 87 | --model $model_name \ 88 | --data custom \ 89 | --features M \ 90 | --seq_len $seq_len \ 91 | --pred_len $pred_len \ 92 | --enc_in 862 \ 93 | --des 'Baseline' \ 94 | --learning_rate 0.05 95 | 96 | python -u run.py \ 97 | --is_training 1 \ 98 | --data_path electricity.csv \ 99 | --task_id Electricity_$seq_len'_'$pred_len \ 100 | --model $model_name \ 101 | --data custom \ 102 | --features M \ 103 | --seq_len $seq_len \ 104 | --pred_len $pred_len \ 105 | --enc_in 321 \ 106 | --des 'Baseline' \ 107 | --learning_rate 0.001 108 | done 109 | for pred_len in 24 36; do 110 | seq_len=36 111 | python -u run.py \ 112 | --is_training 1 \ 113 | --data_path national_illness.csv \ 114 | --task_id national_illness_$seq_len'_'$pred_len \ 115 | --model $model_name \ 116 | --data custom \ 117 | --features M \ 118 | --seq_len $seq_len \ 119 | --label_len 18 \ 120 | --pred_len $pred_len \ 121 | --enc_in 7 \ 122 | --des 'Baseline' \ 123 | --batch_size 32 --learning_rate 0.01 124 | done 125 | -------------------------------------------------------------------------------- /scripts/performance/channel_dependent/Transformer.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=1 2 | 3 | #cd .. 4 | model=Transformer 5 | 6 | for preLen in 48 96; do 7 | 8 | # ETT m1 9 | python -u run.py \ 10 | --is_training 1 \ 11 | --data_path ETTm1.csv \ 12 | --task_id ETTm1 \ 13 | --model $model \ 14 | --data ETTm1 \ 15 | --features M \ 16 | --seq_len 96 \ 17 | --label_len 48 \ 18 | --pred_len $preLen \ 19 | --e_layers 2 \ 20 | --d_layers 1 \ 21 | --factor 3 \ 22 | --enc_in 7 \ 23 | --dec_in 7 \ 24 | --c_out 7 \ 25 | --des 'Exp' \ 26 | --d_model 512 27 | 28 | # ETTh1 29 | python -u run.py \ 30 | --is_training 1 \ 31 | --data_path ETTh1.csv \ 32 | --task_id ETTh1 \ 33 | --model $model \ 34 | --data ETTh1 \ 35 | --features M \ 36 | --seq_len 96 \ 37 | --label_len 48 \ 38 | --pred_len $preLen \ 39 | --e_layers 2 \ 40 | --d_layers 1 \ 41 | --factor 3 \ 42 | --enc_in 7 \ 43 | --dec_in 7 \ 44 | --c_out 7 \ 45 | --des 'Exp' \ 46 | --d_model 512 47 | 48 | # ETTm2 49 | python -u run.py \ 50 | --is_training 1 \ 51 | --data_path ETTm2.csv \ 52 | --task_id ETTm2 \ 53 | --model $model \ 54 | --data ETTm2 \ 55 | --features M \ 56 | --seq_len 96 \ 57 | --label_len 48 \ 58 | --pred_len $preLen \ 59 | --e_layers 2 \ 60 | --d_layers 1 \ 61 | --factor 3 \ 62 | --enc_in 7 \ 63 | --dec_in 7 \ 64 | --c_out 7 \ 65 | --des 'Exp' \ 66 | --d_model 512 67 | 68 | # ETTh2 69 | python -u run.py \ 70 | --is_training 1 \ 71 | --data_path ETTh2.csv \ 72 | --task_id ETTh2 \ 73 | --model $model \ 74 | --data ETTh2 \ 75 | --features M \ 76 | --seq_len 96 \ 77 | --label_len 48 \ 78 | --pred_len $preLen \ 79 | --e_layers 2 \ 80 | --d_layers 1 \ 81 | --factor 3 \ 82 | --enc_in 7 \ 83 | --dec_in 7 \ 84 | --c_out 7 \ 85 | --des 'Exp' \ 86 | --d_model 512 87 | 88 | ## electricity 89 | python -u run.py \ 90 | --is_training 1 \ 91 | --data_path electricity.csv \ 92 | --task_id ECL \ 93 | --model $model \ 94 | --data custom \ 95 | --features M \ 96 | --seq_len 96 \ 97 | --label_len 48 \ 98 | --pred_len $preLen \ 99 | --e_layers 2 \ 100 | --d_layers 1 \ 101 | --factor 3 \ 102 | --enc_in 321 \ 103 | --dec_in 321 \ 104 | --c_out 321 \ 105 | --des 'Exp' 106 | 107 | # exchange 108 | python -u run.py \ 109 | --is_training 1 \ 110 | --data_path exchange_rate.csv \ 111 | --task_id Exchange \ 112 | --model $model \ 113 | --data custom \ 114 | --features M \ 115 | --seq_len 96 \ 116 | --label_len 48 \ 117 | --pred_len $preLen \ 118 | --e_layers 2 \ 119 | --d_layers 1 \ 120 | --factor 3 \ 121 | --enc_in 8 \ 122 | --dec_in 8 \ 123 | --c_out 8 \ 124 | --des 'Exp' 125 | 126 | # traffic 127 | python -u run.py \ 128 | --is_training 1 \ 129 | --data_path traffic.csv \ 130 | --task_id traffic \ 131 | --model $model \ 132 | --data custom \ 133 | --features M \ 134 | --seq_len 96 \ 135 | --label_len 48 \ 136 | --pred_len $preLen \ 137 | --e_layers 2 \ 138 | --d_layers 1 \ 139 | --factor 3 \ 140 | --enc_in 862 \ 141 | --dec_in 862 \ 142 | --c_out 862 \ 143 | --des 'Exp' 144 | 145 | # weather 146 | python -u run.py \ 147 | --is_training 1 \ 148 | --data_path weather.csv \ 149 | --task_id weather \ 150 | --model $model \ 151 | --data custom \ 152 | --features M \ 153 | --seq_len 96 \ 154 | --label_len 48 \ 155 | --pred_len $preLen \ 156 | --e_layers 2 \ 157 | --d_layers 1 \ 158 | --factor 3 \ 159 | --enc_in 21 \ 160 | --dec_in 21 \ 161 | --c_out 21 \ 162 | --des 'Exp' 163 | done 164 | 165 | for preLen in 24 36; do 166 | # illness 167 | python -u run.py \ 168 | --is_training 1 \ 169 | --data_path national_illness.csv \ 170 | --task_id ili \ 171 | --model $model \ 172 | --data custom \ 173 | --features M \ 174 | --seq_len 36 \ 175 | --label_len 18 \ 176 | --pred_len $preLen \ 177 | --e_layers 2 \ 178 | --d_layers 1 \ 179 | --factor 3 \ 180 | --enc_in 7 \ 181 | --dec_in 7 \ 182 | --c_out 7 \ 183 | --des 'Exp' 184 | done 185 | -------------------------------------------------------------------------------- /scripts/performance/channel_independent/DeepVAR.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=1 2 | 3 | #cd .. 4 | model=DeepVAR 5 | 6 | #for preLen in 96 192; do 7 | for preLen in 48 96; do 8 | 9 | # ETT m1 10 | python -u run.py \ 11 | --is_training 1 \ 12 | --data_path ETTm1.csv \ 13 | --task_id ETTm1 \ 14 | --model $model \ 15 | --data ETTm1 \ 16 | --features M \ 17 | --seq_len 96 \ 18 | --label_len 48 \ 19 | --pred_len $preLen \ 20 | --e_layers 2 \ 21 | --d_layers 1 \ 22 | --factor 3 \ 23 | --enc_in 7 \ 24 | --dec_in 7 \ 25 | --c_out 7 \ 26 | --des 'global_dataset' \ 27 | --channel_indepent \ 28 | --batch_size 512 \ 29 | --d_model 64 30 | 31 | # ETTh1 32 | python -u run.py \ 33 | --is_training 1 \ 34 | --data_path ETTh1.csv \ 35 | --task_id ETTh1 \ 36 | --model $model \ 37 | --data ETTh1 \ 38 | --features M \ 39 | --seq_len 96 \ 40 | --label_len 48 \ 41 | --pred_len $preLen \ 42 | --e_layers 2 \ 43 | --d_layers 1 \ 44 | --factor 3 \ 45 | --enc_in 7 \ 46 | --dec_in 7 \ 47 | --c_out 7 \ 48 | --des 'global_dataset' \ 49 | --channel_indepent \ 50 | --batch_size 512 \ 51 | --d_model 64 52 | 53 | # ETTm2 54 | python -u run.py \ 55 | --is_training 1 \ 56 | --data_path ETTm2.csv \ 57 | --task_id ETTm2 \ 58 | --model $model \ 59 | --data ETTm2 \ 60 | --features M \ 61 | --seq_len 96 \ 62 | --label_len 48 \ 63 | --pred_len $preLen \ 64 | --e_layers 2 \ 65 | --d_layers 1 \ 66 | --factor 3 \ 67 | --enc_in 7 \ 68 | --dec_in 7 \ 69 | --c_out 7 \ 70 | --des 'global_dataset' \ 71 | --channel_indepent \ 72 | --batch_size 512 \ 73 | --d_model 64 74 | 75 | # ETTh2 76 | python -u run.py \ 77 | --is_training 1 \ 78 | --data_path ETTh2.csv \ 79 | --task_id ETTh2 \ 80 | --model $model \ 81 | --data ETTh2 \ 82 | --features M \ 83 | --seq_len 96 \ 84 | --label_len 48 \ 85 | --pred_len $preLen \ 86 | --e_layers 2 \ 87 | --d_layers 1 \ 88 | --factor 3 \ 89 | --enc_in 7 \ 90 | --dec_in 7 \ 91 | --c_out 7 \ 92 | --des 'global_dataset' \ 93 | --channel_indepent \ 94 | --batch_size 512 \ 95 | --d_model 64 96 | 97 | ## electricity 98 | python -u run.py \ 99 | --is_training 1 \ 100 | --data_path electricity.csv \ 101 | --task_id ECL \ 102 | --model $model \ 103 | --data custom \ 104 | --features M \ 105 | --seq_len 96 \ 106 | --label_len 48 \ 107 | --pred_len $preLen \ 108 | --e_layers 2 \ 109 | --d_layers 1 \ 110 | --factor 3 \ 111 | --enc_in 321 \ 112 | --dec_in 321 \ 113 | --c_out 321 \ 114 | --des 'global_dataset' \ 115 | --channel_indepent \ 116 | --batch_size 512 \ 117 | --d_model 64 118 | 119 | # exchange 120 | python -u run.py \ 121 | --is_training 1 \ 122 | --data_path exchange_rate.csv \ 123 | --task_id Exchange \ 124 | --model $model \ 125 | --data custom \ 126 | --features M \ 127 | --seq_len 96 \ 128 | --label_len 48 \ 129 | --pred_len $preLen \ 130 | --e_layers 2 \ 131 | --d_layers 1 \ 132 | --factor 3 \ 133 | --enc_in 8 \ 134 | --dec_in 8 \ 135 | --c_out 8 \ 136 | --des 'global_dataset' \ 137 | --channel_indepent \ 138 | --batch_size 512 \ 139 | --d_model 64 140 | 141 | # traffic 142 | python -u run.py \ 143 | --is_training 1 \ 144 | --data_path traffic.csv \ 145 | --task_id traffic \ 146 | --model $model \ 147 | --data custom \ 148 | --features M \ 149 | --seq_len 96 \ 150 | --label_len 48 \ 151 | --pred_len $preLen \ 152 | --e_layers 2 \ 153 | --d_layers 1 \ 154 | --factor 3 \ 155 | --enc_in 862 \ 156 | --dec_in 862 \ 157 | --c_out 862 \ 158 | --des 'global_dataset' \ 159 | --channel_indepent \ 160 | --batch_size 512 \ 161 | --d_model 64 162 | 163 | # weather 164 | python -u run.py \ 165 | --is_training 1 \ 166 | --data_path weather.csv \ 167 | --task_id weather \ 168 | --model $model \ 169 | --data custom \ 170 | --features M \ 171 | --seq_len 96 \ 172 | --label_len 48 \ 173 | --pred_len $preLen \ 174 | --e_layers 2 \ 175 | --d_layers 1 \ 176 | --factor 3 \ 177 | --enc_in 21 \ 178 | --dec_in 21 \ 179 | --c_out 21 \ 180 | --des 'global_dataset' \ 181 | --channel_indepent \ 182 | --batch_size 512 \ 183 | --d_model 64 184 | done 185 | 186 | for preLen in 24 36; do 187 | # illness 188 | python -u run.py \ 189 | --is_training 1 \ 190 | --data_path national_illness.csv \ 191 | --task_id ili \ 192 | --model $model \ 193 | --data custom \ 194 | --features M \ 195 | --seq_len 36 \ 196 | --label_len 18 \ 197 | --pred_len $preLen \ 198 | --e_layers 2 \ 199 | --d_layers 1 \ 200 | --factor 3 \ 201 | --enc_in 7 \ 202 | --dec_in 7 \ 203 | --c_out 7 \ 204 | --des 'global_dataset' \ 205 | --channel_indepent \ 206 | --batch_size 64 \ 207 | --d_model 512 208 | done 209 | -------------------------------------------------------------------------------- /scripts/performance/channel_independent/GBRT.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=1 2 | model_name=gbrt 3 | for pred_len in 48 96; do 4 | seq_len=96 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'Baseline' \ 16 | --channel_independent \ 17 | --batch_size 32 --learning_rate 0.005 18 | 19 | python -u run.py \ 20 | --is_training 1 \ 21 | --data_path ETTh2.csv \ 22 | --task_id ETTh2_$seq_len'_'$pred_len \ 23 | --model $model_name \ 24 | --data ETTh2 \ 25 | --features M \ 26 | --seq_len $seq_len \ 27 | --pred_len $pred_len \ 28 | --enc_in 7 \ 29 | --des 'Baseline' \ 30 | --channel_independent \ 31 | --batch_size 32 --learning_rate 0.05 32 | 33 | python -u run.py \ 34 | --is_training 1 \ 35 | --data_path ETTm1.csv \ 36 | --task_id ETTm1_$seq_len'_'$pred_len \ 37 | --model $model_name \ 38 | --data ETTm1 \ 39 | --features M \ 40 | --seq_len $seq_len \ 41 | --pred_len $pred_len \ 42 | --enc_in 7 \ 43 | --des 'Baseline' \ 44 | --channel_independent \ 45 | --batch_size 8 --learning_rate 0.0001 46 | 47 | python -u run.py \ 48 | --is_training 1 \ 49 | --data_path ETTm2.csv \ 50 | --task_id ETTm2_$seq_len'_'$pred_len \ 51 | --model $model_name \ 52 | --data ETTm2 \ 53 | --features M \ 54 | --seq_len $seq_len \ 55 | --pred_len $pred_len \ 56 | --enc_in 7 \ 57 | --des 'Baseline' \ 58 | --channel_independent \ 59 | --batch_size 32 --learning_rate 0.001 60 | 61 | python -u run.py \ 62 | --is_training 1 \ 63 | --data_path exchange_rate.csv \ 64 | --task_id Exchange_$seq_len'_'$pred_len \ 65 | --model $model_name \ 66 | --data custom \ 67 | --features M \ 68 | --seq_len $seq_len \ 69 | --pred_len $pred_len \ 70 | --enc_in 8 \ 71 | --des 'Baseline' \ 72 | --channel_independent \ 73 | --batch_size 32 --learning_rate 0.0005 74 | 75 | python -u run.py \ 76 | --is_training 1 \ 77 | --data_path weather.csv \ 78 | --task_id weather_$seq_len'_'$pred_len \ 79 | --model $model_name \ 80 | --data custom \ 81 | --features M \ 82 | --seq_len $seq_len \ 83 | --pred_len $pred_len \ 84 | --enc_in 21 \ 85 | --des 'Baseline' \ 86 | --channel_independent \ 87 | --batch_size 32 88 | 89 | python -u run.py \ 90 | --is_training 1 \ 91 | --data_path traffic.csv \ 92 | --task_id traffic_$seq_len'_'$pred_len \ 93 | --model $model_name \ 94 | --data custom \ 95 | --features M \ 96 | --seq_len $seq_len \ 97 | --pred_len $pred_len \ 98 | --enc_in 862 \ 99 | --des 'Baseline' \ 100 | --channel_independent \ 101 | --learning_rate 0.05 102 | 103 | python -u run.py \ 104 | --is_training 1 \ 105 | --data_path electricity.csv \ 106 | --task_id Electricity_$seq_len'_'$pred_len \ 107 | --model $model_name \ 108 | --data custom \ 109 | --features M \ 110 | --seq_len $seq_len \ 111 | --pred_len $pred_len \ 112 | --enc_in 321 \ 113 | --des 'Baseline' \ 114 | --channel_independent \ 115 | --learning_rate 0.001 116 | done 117 | 118 | for pred_len in 24 36; do 119 | seq_len=36 120 | python -u run.py \ 121 | --is_training 1 \ 122 | --data_path national_illness.csv \ 123 | --task_id national_illness_$seq_len'_'$pred_len \ 124 | --model $model_name \ 125 | --data custom \ 126 | --features M \ 127 | --seq_len $seq_len \ 128 | --label_len 18 \ 129 | --pred_len $pred_len \ 130 | --enc_in 7 \ 131 | --des 'Baseline' \ 132 | --channel_independent \ 133 | --batch_size 32 --learning_rate 0.01 134 | done 135 | -------------------------------------------------------------------------------- /scripts/performance/channel_independent/Informer.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=3 2 | 3 | #cd .. 4 | model=Informer 5 | 6 | #for preLen in 96 192 336 720; do 7 | for preLen in 48; do 8 | 9 | # ETT m1 10 | python -u run.py \ 11 | --is_training 1 \ 12 | --data_path ETTm1.csv \ 13 | --task_id ETTm1 \ 14 | --model $model \ 15 | --data ETTm1 \ 16 | --features M \ 17 | --seq_len 96 \ 18 | --label_len 48 \ 19 | --pred_len $preLen \ 20 | --e_layers 2 \ 21 | --d_layers 1 \ 22 | --factor 3 \ 23 | --enc_in 7 \ 24 | --dec_in 7 \ 25 | --c_out 7 \ 26 | --des 'global_dataset' \ 27 | --channel_independent \ 28 | --batch_size 512 \ 29 | --d_model 64 30 | 31 | # ETTh1 32 | python -u run.py \ 33 | --is_training 1 \ 34 | --data_path ETTh1.csv \ 35 | --task_id ETTh1 \ 36 | --model $model \ 37 | --data ETTh1 \ 38 | --features M \ 39 | --seq_len 96 \ 40 | --label_len 48 \ 41 | --pred_len $preLen \ 42 | --e_layers 2 \ 43 | --d_layers 1 \ 44 | --factor 3 \ 45 | --enc_in 7 \ 46 | --dec_in 7 \ 47 | --c_out 7 \ 48 | --des 'global_dataset' \ 49 | --channel_independent \ 50 | --batch_size 512 \ 51 | --d_model 64 52 | 53 | # ETTm2 54 | python -u run.py \ 55 | --is_training 1 \ 56 | --data_path ETTm2.csv \ 57 | --task_id ETTm2 \ 58 | --model $model \ 59 | --data ETTm2 \ 60 | --features M \ 61 | --seq_len 96 \ 62 | --label_len 48 \ 63 | --pred_len $preLen \ 64 | --e_layers 2 \ 65 | --d_layers 1 \ 66 | --factor 3 \ 67 | --enc_in 7 \ 68 | --dec_in 7 \ 69 | --c_out 7 \ 70 | --des 'global_dataset' \ 71 | --channel_independent \ 72 | --batch_size 512 \ 73 | --d_model 64 74 | 75 | # ETTh2 76 | python -u run.py \ 77 | --is_training 1 \ 78 | --data_path ETTh2.csv \ 79 | --task_id ETTh2 \ 80 | --model $model \ 81 | --data ETTh2 \ 82 | --features M \ 83 | --seq_len 96 \ 84 | --label_len 48 \ 85 | --pred_len $preLen \ 86 | --e_layers 2 \ 87 | --d_layers 1 \ 88 | --factor 3 \ 89 | --enc_in 7 \ 90 | --dec_in 7 \ 91 | --c_out 7 \ 92 | --des 'global_dataset' \ 93 | --channel_independent \ 94 | --batch_size 512 \ 95 | --d_model 64 96 | 97 | ## electricity 98 | python -u run.py \ 99 | --is_training 1 \ 100 | --data_path electricity.csv \ 101 | --task_id ECL \ 102 | --model $model \ 103 | --data custom \ 104 | --features M \ 105 | --seq_len 96 \ 106 | --label_len 48 \ 107 | --pred_len $preLen \ 108 | --e_layers 2 \ 109 | --d_layers 1 \ 110 | --factor 3 \ 111 | --enc_in 321 \ 112 | --dec_in 321 \ 113 | --c_out 321 \ 114 | --des 'global_dataset' \ 115 | --channel_independent \ 116 | --batch_size 512 \ 117 | --d_model 64 118 | 119 | # exchange 120 | python -u run.py \ 121 | --is_training 1 \ 122 | --data_path exchange_rate.csv \ 123 | --task_id Exchange \ 124 | --model $model \ 125 | --data custom \ 126 | --features M \ 127 | --seq_len 96 \ 128 | --label_len 48 \ 129 | --pred_len $preLen \ 130 | --e_layers 2 \ 131 | --d_layers 1 \ 132 | --factor 3 \ 133 | --enc_in 8 \ 134 | --dec_in 8 \ 135 | --c_out 8 \ 136 | --des 'global_dataset' \ 137 | --channel_independent \ 138 | --batch_size 512 \ 139 | --d_model 64 140 | 141 | # traffic 142 | python -u run.py \ 143 | --is_training 1 \ 144 | --data_path traffic.csv \ 145 | --task_id traffic \ 146 | --model $model \ 147 | --data custom \ 148 | --features M \ 149 | --seq_len 96 \ 150 | --label_len 48 \ 151 | --pred_len $preLen \ 152 | --e_layers 2 \ 153 | --d_layers 1 \ 154 | --factor 3 \ 155 | --enc_in 862 \ 156 | --dec_in 862 \ 157 | --c_out 862 \ 158 | --des 'global_dataset' \ 159 | --channel_independent \ 160 | --batch_size 512 \ 161 | --d_model 64 162 | 163 | # weather 164 | python -u run.py \ 165 | --is_training 1 \ 166 | --data_path weather.csv \ 167 | --task_id weather \ 168 | --model $model \ 169 | --data custom \ 170 | --features M \ 171 | --seq_len 96 \ 172 | --label_len 48 \ 173 | --pred_len $preLen \ 174 | --e_layers 2 \ 175 | --d_layers 1 \ 176 | --factor 3 \ 177 | --enc_in 21 \ 178 | --dec_in 21 \ 179 | --c_out 21 \ 180 | --des 'global_dataset' \ 181 | --channel_independent \ 182 | --batch_size 512 \ 183 | --d_model 64 184 | done 185 | 186 | #for preLen in 24 36 48 60; do 187 | # # illness 188 | # python -u run.py \ 189 | # --is_training 1 \ 190 | # --data_path national_illness.csv \ 191 | # --task_id ili \ 192 | # --model $model \ 193 | # --data custom \ 194 | # --features M \ 195 | # --seq_len 36 \ 196 | # --label_len 18 \ 197 | # --pred_len $preLen \ 198 | # --e_layers 2 \ 199 | # --d_layers 1 \ 200 | # --factor 3 \ 201 | # --enc_in 7 \ 202 | # --dec_in 7 \ 203 | # --c_out 7 \ 204 | # --des 'global_dataset' \ 205 | # --channel_independent \ 206 | # --batch_size 64 \ 207 | # --d_model 512 208 | #done 209 | -------------------------------------------------------------------------------- /scripts/performance/channel_independent/Linear.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=0 2 | model_name=Linear 3 | for pred_len in 48 96; do 4 | seq_len=96 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'global_dataset' \ 16 | --batch_size 32 --learning_rate 0.005 17 | 18 | python -u run.py \ 19 | --is_training 1 \ 20 | --data_path ETTh2.csv \ 21 | --task_id ETTh2_$seq_len'_'$pred_len \ 22 | --model $model_name \ 23 | --data ETTh2 \ 24 | --features M \ 25 | --seq_len $seq_len \ 26 | --pred_len $pred_len \ 27 | --enc_in 7 \ 28 | --des 'global_dataset' \ 29 | --batch_size 32 --learning_rate 0.05 30 | 31 | python -u run.py \ 32 | --is_training 1 \ 33 | --data_path ETTm1.csv \ 34 | --task_id ETTm1_$seq_len'_'$pred_len \ 35 | --model $model_name \ 36 | --data ETTm1 \ 37 | --features M \ 38 | --seq_len $seq_len \ 39 | --pred_len $pred_len \ 40 | --enc_in 7 \ 41 | --des 'global_dataset' \ 42 | --batch_size 8 --learning_rate 0.0001 43 | 44 | python -u run.py \ 45 | --is_training 1 \ 46 | --data_path ETTm2.csv \ 47 | --task_id ETTm2_$seq_len'_'$pred_len \ 48 | --model $model_name \ 49 | --data ETTm2 \ 50 | --features M \ 51 | --seq_len $seq_len \ 52 | --pred_len $pred_len \ 53 | --enc_in 7 \ 54 | --des 'global_dataset' \ 55 | --batch_size 32 --learning_rate 0.001 56 | 57 | python -u run.py \ 58 | --is_training 1 \ 59 | --data_path exchange_rate.csv \ 60 | --task_id Exchange_$seq_len'_'$pred_len \ 61 | --model $model_name \ 62 | --data custom \ 63 | --features M \ 64 | --seq_len $seq_len \ 65 | --pred_len $pred_len \ 66 | --enc_in 8 \ 67 | --des 'global_dataset' \ 68 | --batch_size 32 --learning_rate 0.0005 69 | 70 | python -u run.py \ 71 | --is_training 1 \ 72 | --data_path weather.csv \ 73 | --task_id weather_$seq_len'_'$pred_len \ 74 | --model $model_name \ 75 | --data custom \ 76 | --features M \ 77 | --seq_len $seq_len \ 78 | --pred_len $pred_len \ 79 | --enc_in 21 \ 80 | --des 'global_dataset' \ 81 | --batch_size 32 82 | 83 | python -u run.py \ 84 | --is_training 1 \ 85 | --data_path traffic.csv \ 86 | --task_id traffic_$seq_len'_'$pred_len \ 87 | --model $model_name \ 88 | --data custom \ 89 | --features M \ 90 | --seq_len $seq_len \ 91 | --pred_len $pred_len \ 92 | --enc_in 862 \ 93 | --des 'global_dataset' \ 94 | --learning_rate 0.05 95 | 96 | python -u run.py \ 97 | --is_training 1 \ 98 | --data_path electricity.csv \ 99 | --task_id Electricity_$seq_len'_'$pred_len \ 100 | --model $model_name \ 101 | --data custom \ 102 | --features M \ 103 | --seq_len $seq_len \ 104 | --pred_len $pred_len \ 105 | --enc_in 321 \ 106 | --des 'global_dataset' \ 107 | --learning_rate 0.001 108 | done 109 | for pred_len in 24 36; do 110 | seq_len=36 111 | python -u run.py \ 112 | --is_training 1 \ 113 | --data_path national_illness.csv \ 114 | --task_id national_illness_$seq_len'_'$pred_len \ 115 | --model $model_name \ 116 | --data custom \ 117 | --features M \ 118 | --seq_len $seq_len \ 119 | --label_len 18 \ 120 | --pred_len $pred_len \ 121 | --enc_in 7 \ 122 | --des 'global_dataset' \ 123 | --batch_size 32 --learning_rate 0.01 124 | done 125 | -------------------------------------------------------------------------------- /scripts/performance/channel_independent/MLP.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=1 2 | model_name=MLP 3 | for pred_len in 48 96; do 4 | seq_len=96 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'global_dataset' \ 16 | --channel_independent \ 17 | --batch_size 512 --learning_rate 0.005 18 | 19 | python -u run.py \ 20 | --is_training 1 \ 21 | --data_path ETTh2.csv \ 22 | --task_id ETTh2_$seq_len'_'$pred_len \ 23 | --model $model_name \ 24 | --data ETTh2 \ 25 | --features M \ 26 | --seq_len $seq_len \ 27 | --pred_len $pred_len \ 28 | --enc_in 7 \ 29 | --des 'global_dataset' \ 30 | --channel_independent \ 31 | --batch_size 512 --learning_rate 0.05 32 | 33 | python -u run.py \ 34 | --is_training 1 \ 35 | --data_path ETTm1.csv \ 36 | --task_id ETTm1_$seq_len'_'$pred_len \ 37 | --model $model_name \ 38 | --data ETTm1 \ 39 | --features M \ 40 | --seq_len $seq_len \ 41 | --pred_len $pred_len \ 42 | --enc_in 7 \ 43 | --des 'global_dataset' \ 44 | --channel_independent \ 45 | --batch_size 512 \ 46 | --learning_rate 0.0001 47 | 48 | python -u run.py \ 49 | --is_training 1 \ 50 | --data_path ETTm2.csv \ 51 | --task_id ETTm2_$seq_len'_'$pred_len \ 52 | --model $model_name \ 53 | --data ETTm2 \ 54 | --features M \ 55 | --seq_len $seq_len \ 56 | --pred_len $pred_len \ 57 | --enc_in 7 \ 58 | --des 'global_dataset' \ 59 | --channel_independent \ 60 | --batch_size 512 --learning_rate 0.001 61 | 62 | python -u run.py \ 63 | --is_training 1 \ 64 | --data_path exchange_rate.csv \ 65 | --task_id Exchange_$seq_len'_'$pred_len \ 66 | --model $model_name \ 67 | --data custom \ 68 | --features M \ 69 | --seq_len $seq_len \ 70 | --pred_len $pred_len \ 71 | --enc_in 8 \ 72 | --des 'global_dataset' \ 73 | --channel_independent \ 74 | --batch_size 512 --learning_rate 0.0005 75 | 76 | python -u run.py \ 77 | --is_training 1 \ 78 | --data_path weather.csv \ 79 | --task_id weather_$seq_len'_'$pred_len \ 80 | --model $model_name \ 81 | --data custom \ 82 | --features M \ 83 | --seq_len $seq_len \ 84 | --pred_len $pred_len \ 85 | --enc_in 21 \ 86 | --des 'global_dataset' \ 87 | --channel_independent \ 88 | --batch_size 512 89 | 90 | python -u run.py \ 91 | --is_training 1 \ 92 | --data_path traffic.csv \ 93 | --task_id traffic_$seq_len'_'$pred_len \ 94 | --model $model_name \ 95 | --data custom \ 96 | --features M \ 97 | --seq_len $seq_len \ 98 | --pred_len $pred_len \ 99 | --enc_in 862 \ 100 | --des 'global_dataset' \ 101 | --channel_independent \ 102 | --batch_size 512 \ 103 | --learning_rate 0.05 104 | 105 | python -u run.py \ 106 | --is_training 1 \ 107 | --data_path electricity.csv \ 108 | --task_id Electricity_$seq_len'_'$pred_len \ 109 | --model $model_name \ 110 | --data custom \ 111 | --features M \ 112 | --seq_len $seq_len \ 113 | --pred_len $pred_len \ 114 | --enc_in 321 \ 115 | --des 'global_dataset' \ 116 | --channel_independent \ 117 | --batch_size 512 \ 118 | --learning_rate 0.001 119 | done 120 | for pred_len in 24 36; do 121 | seq_len=36 122 | python -u run.py \ 123 | --is_training 1 \ 124 | --data_path national_illness.csv \ 125 | --task_id national_illness_$seq_len'_'$pred_len \ 126 | --model $model_name \ 127 | --data custom \ 128 | --features M \ 129 | --seq_len $seq_len \ 130 | --label_len 18 \ 131 | --pred_len $pred_len \ 132 | --enc_in 7 \ 133 | --des 'global_dataset' \ 134 | --channel_independent \ 135 | --batch_size 512 --learning_rate 0.01 136 | done 137 | -------------------------------------------------------------------------------- /scripts/performance/channel_independent/TCN.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=3 2 | model_name=TCN 3 | for pred_len in 48 96; do 4 | seq_len=96 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'global_dataset' \ 16 | --channel_independent \ 17 | --batch_size 512 --learning_rate 0.005 18 | 19 | python -u run.py \ 20 | --is_training 1 \ 21 | --data_path ETTh2.csv \ 22 | --task_id ETTh2_$seq_len'_'$pred_len \ 23 | --model $model_name \ 24 | --data ETTh2 \ 25 | --features M \ 26 | --seq_len $seq_len \ 27 | --pred_len $pred_len \ 28 | --enc_in 7 \ 29 | --des 'global_dataset' \ 30 | --channel_independent \ 31 | --batch_size 512 --learning_rate 0.05 32 | 33 | python -u run.py \ 34 | --is_training 1 \ 35 | --data_path ETTm1.csv \ 36 | --task_id ETTm1_$seq_len'_'$pred_len \ 37 | --model $model_name \ 38 | --data ETTm1 \ 39 | --features M \ 40 | --seq_len $seq_len \ 41 | --pred_len $pred_len \ 42 | --enc_in 7 \ 43 | --des 'global_dataset' \ 44 | --channel_independent \ 45 | --batch_size 512 \ 46 | --learning_rate 0.0001 47 | 48 | python -u run.py \ 49 | --is_training 1 \ 50 | --data_path ETTm2.csv \ 51 | --task_id ETTm2_$seq_len'_'$pred_len \ 52 | --model $model_name \ 53 | --data ETTm2 \ 54 | --features M \ 55 | --seq_len $seq_len \ 56 | --pred_len $pred_len \ 57 | --enc_in 7 \ 58 | --des 'global_dataset' \ 59 | --channel_independent \ 60 | --batch_size 512 --learning_rate 0.001 61 | 62 | python -u run.py \ 63 | --is_training 1 \ 64 | --data_path exchange_rate.csv \ 65 | --task_id Exchange_$seq_len'_'$pred_len \ 66 | --model $model_name \ 67 | --data custom \ 68 | --features M \ 69 | --seq_len $seq_len \ 70 | --pred_len $pred_len \ 71 | --enc_in 8 \ 72 | --des 'global_dataset' \ 73 | --channel_independent \ 74 | --batch_size 512 --learning_rate 0.0005 75 | 76 | python -u run.py \ 77 | --is_training 1 \ 78 | --data_path weather.csv \ 79 | --task_id weather_$seq_len'_'$pred_len \ 80 | --model $model_name \ 81 | --data custom \ 82 | --features M \ 83 | --seq_len $seq_len \ 84 | --pred_len $pred_len \ 85 | --enc_in 21 \ 86 | --des 'global_dataset' \ 87 | --channel_independent \ 88 | --batch_size 512 89 | 90 | python -u run.py \ 91 | --is_training 1 \ 92 | --data_path traffic.csv \ 93 | --task_id traffic_$seq_len'_'$pred_len \ 94 | --model $model_name \ 95 | --data custom \ 96 | --features M \ 97 | --seq_len $seq_len \ 98 | --pred_len $pred_len \ 99 | --enc_in 862 \ 100 | --des 'global_dataset' \ 101 | --channel_independent \ 102 | --batch_size 512 \ 103 | --learning_rate 0.05 104 | 105 | python -u run.py \ 106 | --is_training 1 \ 107 | --data_path electricity.csv \ 108 | --task_id Electricity_$seq_len'_'$pred_len \ 109 | --model $model_name \ 110 | --data custom \ 111 | --features M \ 112 | --seq_len $seq_len \ 113 | --pred_len $pred_len \ 114 | --enc_in 321 \ 115 | --des 'global_dataset' \ 116 | --channel_independent \ 117 | --batch_size 512 \ 118 | --learning_rate 0.001 119 | done 120 | for pred_len in 24 36; do 121 | seq_len=36 122 | python -u run.py \ 123 | --is_training 1 \ 124 | --data_path national_illness.csv \ 125 | --task_id national_illness_$seq_len'_'$pred_len \ 126 | --model $model_name \ 127 | --data custom \ 128 | --features M \ 129 | --seq_len $seq_len \ 130 | --label_len 18 \ 131 | --pred_len $pred_len \ 132 | --enc_in 7 \ 133 | --des 'global_dataset' \ 134 | --channel_independent \ 135 | --batch_size 512 --learning_rate 0.01 136 | done 137 | -------------------------------------------------------------------------------- /scripts/performance/channel_independent/Transformer.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=0 2 | 3 | #cd .. 4 | model=Transformer 5 | 6 | for preLen in 48; do 7 | 8 | # ETT m1 9 | python -u run.py \ 10 | --is_training 1 \ 11 | --data_path ETTm1.csv \ 12 | --task_id ETTm1 \ 13 | --model $model \ 14 | --data ETTm1 \ 15 | --features M \ 16 | --seq_len 96 \ 17 | --label_len 48 \ 18 | --pred_len $preLen \ 19 | --e_layers 2 \ 20 | --d_layers 1 \ 21 | --factor 3 \ 22 | --enc_in 7 \ 23 | --dec_in 7 \ 24 | --c_out 7 \ 25 | --des 'global_dataset' \ 26 | --channel_independent \ 27 | --batch_size 512 \ 28 | --d_model 64 29 | 30 | # ETTh1 31 | python -u run.py \ 32 | --is_training 1 \ 33 | --data_path ETTh1.csv \ 34 | --task_id ETTh1 \ 35 | --model $model \ 36 | --data ETTh1 \ 37 | --features M \ 38 | --seq_len 96 \ 39 | --label_len 48 \ 40 | --pred_len $preLen \ 41 | --e_layers 2 \ 42 | --d_layers 1 \ 43 | --factor 3 \ 44 | --enc_in 7 \ 45 | --dec_in 7 \ 46 | --c_out 7 \ 47 | --des 'global_dataset' \ 48 | --channel_independent \ 49 | --batch_size 512 \ 50 | --d_model 64 51 | 52 | # ETTm2 53 | python -u run.py \ 54 | --is_training 1 \ 55 | --data_path ETTm2.csv \ 56 | --task_id ETTm2 \ 57 | --model $model \ 58 | --data ETTm2 \ 59 | --features M \ 60 | --seq_len 96 \ 61 | --label_len 48 \ 62 | --pred_len $preLen \ 63 | --e_layers 2 \ 64 | --d_layers 1 \ 65 | --factor 3 \ 66 | --enc_in 7 \ 67 | --dec_in 7 \ 68 | --c_out 7 \ 69 | --des 'global_dataset' \ 70 | --channel_independent \ 71 | --batch_size 512 \ 72 | --d_model 64 73 | 74 | # ETTh2 75 | python -u run.py \ 76 | --is_training 1 \ 77 | --data_path ETTh2.csv \ 78 | --task_id ETTh2 \ 79 | --model $model \ 80 | --data ETTh2 \ 81 | --features M \ 82 | --seq_len 96 \ 83 | --label_len 48 \ 84 | --pred_len $preLen \ 85 | --e_layers 2 \ 86 | --d_layers 1 \ 87 | --factor 3 \ 88 | --enc_in 7 \ 89 | --dec_in 7 \ 90 | --c_out 7 \ 91 | --des 'global_dataset' \ 92 | --channel_independent \ 93 | --batch_size 512 \ 94 | --d_model 64 95 | 96 | ## electricity 97 | python -u run.py \ 98 | --is_training 1 \ 99 | --data_path electricity.csv \ 100 | --task_id ECL \ 101 | --model $model \ 102 | --data custom \ 103 | --features M \ 104 | --seq_len 96 \ 105 | --label_len 48 \ 106 | --pred_len $preLen \ 107 | --e_layers 2 \ 108 | --d_layers 1 \ 109 | --factor 3 \ 110 | --enc_in 321 \ 111 | --dec_in 321 \ 112 | --c_out 321 \ 113 | --des 'global_dataset' \ 114 | --channel_independent \ 115 | --batch_size 512 \ 116 | --d_model 64 117 | 118 | # exchange 119 | python -u run.py \ 120 | --is_training 1 \ 121 | --data_path exchange_rate.csv \ 122 | --task_id Exchange \ 123 | --model $model \ 124 | --data custom \ 125 | --features M \ 126 | --seq_len 96 \ 127 | --label_len 48 \ 128 | --pred_len $preLen \ 129 | --e_layers 2 \ 130 | --d_layers 1 \ 131 | --factor 3 \ 132 | --enc_in 8 \ 133 | --dec_in 8 \ 134 | --c_out 8 \ 135 | --des 'global_dataset' \ 136 | --channel_independent \ 137 | --batch_size 512 \ 138 | --d_model 64 139 | 140 | # traffic 141 | python -u run.py \ 142 | --is_training 1 \ 143 | --data_path traffic.csv \ 144 | --task_id traffic \ 145 | --model $model \ 146 | --data custom \ 147 | --features M \ 148 | --seq_len 96 \ 149 | --label_len 48 \ 150 | --pred_len $preLen \ 151 | --e_layers 2 \ 152 | --d_layers 1 \ 153 | --factor 3 \ 154 | --enc_in 862 \ 155 | --dec_in 862 \ 156 | --c_out 862 \ 157 | --des 'global_dataset' \ 158 | --channel_independent \ 159 | --batch_size 512 \ 160 | --d_model 64 161 | 162 | # weather 163 | python -u run.py \ 164 | --is_training 1 \ 165 | --data_path weather.csv \ 166 | --task_id weather \ 167 | --model $model \ 168 | --data custom \ 169 | --features M \ 170 | --seq_len 96 \ 171 | --label_len 48 \ 172 | --pred_len $preLen \ 173 | --e_layers 2 \ 174 | --d_layers 1 \ 175 | --factor 3 \ 176 | --enc_in 21 \ 177 | --dec_in 21 \ 178 | --c_out 21 \ 179 | --des 'global_dataset' \ 180 | --channel_independent \ 181 | --batch_size 512 \ 182 | --d_model 64 183 | done 184 | 185 | #for preLen in 24 36 48 60; do 186 | # # illness 187 | # python -u run.py \ 188 | # --is_training 1 \ 189 | # --data_path national_illness.csv \ 190 | # --task_id ili \ 191 | # --model $model \ 192 | # --data custom \ 193 | # --features M \ 194 | # --seq_len 36 \ 195 | # --label_len 18 \ 196 | # --pred_len $preLen \ 197 | # --e_layers 2 \ 198 | # --d_layers 1 \ 199 | # --factor 3 \ 200 | # --enc_in 7 \ 201 | # --dec_in 7 \ 202 | # --c_out 7 \ 203 | # --des 'global_dataset' \ 204 | # --channel_independent \ 205 | # --batch_size 64 \ 206 | # --d_model 512 207 | #done 208 | -------------------------------------------------------------------------------- /scripts/prreg/Transformer.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=0 2 | 3 | #cd .. 4 | model=Transformer 5 | for wd in 1e-6 1e-5 1e-4 1e-3 1e-2 0.1 1.0; do 6 | for preLen in 48; do 7 | # ETT m1 8 | python -u run.py \ 9 | --is_training 1 \ 10 | --data_path ETTm1.csv \ 11 | --task_id ETTm1 \ 12 | --model $model \ 13 | --data ETTm1 \ 14 | --features M \ 15 | --seq_len 96 \ 16 | --label_len 48 \ 17 | --pred_len $preLen \ 18 | --e_layers 2 \ 19 | --d_layers 1 \ 20 | --factor 3 \ 21 | --enc_in 7 \ 22 | --dec_in 7 \ 23 | --c_out 7 \ 24 | --des 'only output' \ 25 | --wd $wd \ 26 | --pred_residual \ 27 | --d_model 512 28 | 29 | # ETTh1 30 | python -u run.py \ 31 | --is_training 1 \ 32 | --data_path ETTh1.csv \ 33 | --task_id ETTh1 \ 34 | --model $model \ 35 | --data ETTh1 \ 36 | --features M \ 37 | --seq_len 96 \ 38 | --label_len 48 \ 39 | --pred_len $preLen \ 40 | --e_layers 2 \ 41 | --d_layers 1 \ 42 | --factor 3 \ 43 | --enc_in 7 \ 44 | --dec_in 7 \ 45 | --c_out 7 \ 46 | --des 'only output' \ 47 | --wd $wd \ 48 | --pred_residual \ 49 | --d_model 512 50 | 51 | # ETTm2 52 | python -u run.py \ 53 | --is_training 1 \ 54 | --data_path ETTm2.csv \ 55 | --task_id ETTm2 \ 56 | --model $model \ 57 | --data ETTm2 \ 58 | --features M \ 59 | --seq_len 96 \ 60 | --label_len 48 \ 61 | --pred_len $preLen \ 62 | --e_layers 2 \ 63 | --d_layers 1 \ 64 | --factor 3 \ 65 | --enc_in 7 \ 66 | --dec_in 7 \ 67 | --c_out 7 \ 68 | --des 'only output' \ 69 | --wd $wd \ 70 | --pred_residual \ 71 | --d_model 512 72 | 73 | # ETTh2 74 | python -u run.py \ 75 | --is_training 1 \ 76 | --data_path ETTh2.csv \ 77 | --task_id ETTh2 \ 78 | --model $model \ 79 | --data ETTh2 \ 80 | --features M \ 81 | --seq_len 96 \ 82 | --label_len 48 \ 83 | --pred_len $preLen \ 84 | --e_layers 2 \ 85 | --d_layers 1 \ 86 | --factor 3 \ 87 | --enc_in 7 \ 88 | --dec_in 7 \ 89 | --c_out 7 \ 90 | --des 'only output' \ 91 | --wd $wd \ 92 | --pred_residual \ 93 | --d_model 512 94 | 95 | ## electricity 96 | python -u run.py \ 97 | --is_training 1 \ 98 | --data_path electricity.csv \ 99 | --task_id ECL \ 100 | --model $model \ 101 | --data custom \ 102 | --features M \ 103 | --seq_len 96 \ 104 | --label_len 48 \ 105 | --pred_len $preLen \ 106 | --e_layers 2 \ 107 | --d_layers 1 \ 108 | --factor 3 \ 109 | --enc_in 321 \ 110 | --dec_in 321 \ 111 | --c_out 321 \ 112 | --des 'only output' \ 113 | --wd $wd \ 114 | --pred_residual 115 | 116 | # exchange 117 | python -u run.py \ 118 | --is_training 1 \ 119 | --data_path exchange_rate.csv \ 120 | --task_id Exchange \ 121 | --model $model \ 122 | --data custom \ 123 | --features M \ 124 | --seq_len 96 \ 125 | --label_len 48 \ 126 | --pred_len $preLen \ 127 | --e_layers 2 \ 128 | --d_layers 1 \ 129 | --factor 3 \ 130 | --enc_in 8 \ 131 | --dec_in 8 \ 132 | --c_out 8 \ 133 | --des 'only output' \ 134 | --wd $wd \ 135 | --pred_residual 136 | 137 | # traffic 138 | python -u run.py \ 139 | --is_training 1 \ 140 | --data_path traffic.csv \ 141 | --task_id traffic \ 142 | --model $model \ 143 | --data custom \ 144 | --features M \ 145 | --seq_len 96 \ 146 | --label_len 48 \ 147 | --pred_len $preLen \ 148 | --e_layers 2 \ 149 | --d_layers 1 \ 150 | --factor 3 \ 151 | --enc_in 862 \ 152 | --dec_in 862 \ 153 | --c_out 862 \ 154 | --des 'only output' \ 155 | --wd $wd \ 156 | --pred_residual 157 | 158 | # weather 159 | python -u run.py \ 160 | --is_training 1 \ 161 | --data_path weather.csv \ 162 | --task_id weather \ 163 | --model $model \ 164 | --data custom \ 165 | --features M \ 166 | --seq_len 96 \ 167 | --label_len 48 \ 168 | --pred_len $preLen \ 169 | --e_layers 2 \ 170 | --d_layers 1 \ 171 | --factor 3 \ 172 | --enc_in 21 \ 173 | --dec_in 21 \ 174 | --c_out 21 \ 175 | --des 'only output' \ 176 | --wd $wd \ 177 | --pred_residual 178 | done 179 | 180 | for preLen in 24; do 181 | # illness 182 | python -u run.py \ 183 | --is_training 1 \ 184 | --data_path national_illness.csv \ 185 | --task_id ili \ 186 | --model $model \ 187 | --data custom \ 188 | --features M \ 189 | --seq_len 36 \ 190 | --label_len 18 \ 191 | --pred_len $preLen \ 192 | --e_layers 2 \ 193 | --d_layers 1 \ 194 | --factor 3 \ 195 | --enc_in 7 \ 196 | --dec_in 7 \ 197 | --c_out 7 \ 198 | --des 'only output' \ 199 | --wd $wd \ 200 | --pred_residual 201 | done 202 | done 203 | -------------------------------------------------------------------------------- /scripts/prreg/Transformer_CI.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=0 2 | 3 | #cd .. 4 | model=Transformer 5 | for wd in 1e-6 1e-5 1e-4 1e-3 1e-2 0.1 1.0; do 6 | for preLen in 48; do 7 | # ETT m1 8 | python -u run.py \ 9 | --is_training 1 \ 10 | --data_path ETTm1.csv \ 11 | --task_id ETTm1 \ 12 | --model $model \ 13 | --data ETTm1 \ 14 | --features M \ 15 | --seq_len 96 \ 16 | --label_len 48 \ 17 | --pred_len $preLen \ 18 | --e_layers 2 \ 19 | --d_layers 1 \ 20 | --factor 3 \ 21 | --enc_in 7 \ 22 | --dec_in 7 \ 23 | --c_out 7 \ 24 | --des 'only output' \ 25 | --channel_independent \ 26 | --wd $wd \ 27 | --pred_residual \ 28 | --d_model 512 29 | 30 | # ETTh1 31 | python -u run.py \ 32 | --is_training 1 \ 33 | --data_path ETTh1.csv \ 34 | --task_id ETTh1 \ 35 | --model $model \ 36 | --data ETTh1 \ 37 | --features M \ 38 | --seq_len 96 \ 39 | --label_len 48 \ 40 | --pred_len $preLen \ 41 | --e_layers 2 \ 42 | --d_layers 1 \ 43 | --factor 3 \ 44 | --enc_in 7 \ 45 | --dec_in 7 \ 46 | --c_out 7 \ 47 | --des 'only output' \ 48 | --channel_independent \ 49 | --wd $wd \ 50 | --pred_residual \ 51 | --d_model 512 52 | 53 | # ETTm2 54 | python -u run.py \ 55 | --is_training 1 \ 56 | --data_path ETTm2.csv \ 57 | --task_id ETTm2 \ 58 | --model $model \ 59 | --data ETTm2 \ 60 | --features M \ 61 | --seq_len 96 \ 62 | --label_len 48 \ 63 | --pred_len $preLen \ 64 | --e_layers 2 \ 65 | --d_layers 1 \ 66 | --factor 3 \ 67 | --enc_in 7 \ 68 | --dec_in 7 \ 69 | --c_out 7 \ 70 | --des 'only output' \ 71 | --channel_independent \ 72 | --wd $wd \ 73 | --pred_residual \ 74 | --d_model 512 75 | 76 | # ETTh2 77 | python -u run.py \ 78 | --is_training 1 \ 79 | --data_path ETTh2.csv \ 80 | --task_id ETTh2 \ 81 | --model $model \ 82 | --data ETTh2 \ 83 | --features M \ 84 | --seq_len 96 \ 85 | --label_len 48 \ 86 | --pred_len $preLen \ 87 | --e_layers 2 \ 88 | --d_layers 1 \ 89 | --factor 3 \ 90 | --enc_in 7 \ 91 | --dec_in 7 \ 92 | --c_out 7 \ 93 | --des 'only output' \ 94 | --channel_independent \ 95 | --wd $wd \ 96 | --pred_residual \ 97 | --d_model 512 98 | 99 | ## electricity 100 | python -u run.py \ 101 | --is_training 1 \ 102 | --data_path electricity.csv \ 103 | --task_id ECL \ 104 | --model $model \ 105 | --data custom \ 106 | --features M \ 107 | --seq_len 96 \ 108 | --label_len 48 \ 109 | --pred_len $preLen \ 110 | --e_layers 2 \ 111 | --d_layers 1 \ 112 | --factor 3 \ 113 | --enc_in 321 \ 114 | --dec_in 321 \ 115 | --c_out 321 \ 116 | --des 'only output' \ 117 | --channel_independent \ 118 | --wd $wd \ 119 | --pred_residual 120 | 121 | # exchange 122 | python -u run.py \ 123 | --is_training 1 \ 124 | --data_path exchange_rate.csv \ 125 | --task_id Exchange \ 126 | --model $model \ 127 | --data custom \ 128 | --features M \ 129 | --seq_len 96 \ 130 | --label_len 48 \ 131 | --pred_len $preLen \ 132 | --e_layers 2 \ 133 | --d_layers 1 \ 134 | --factor 3 \ 135 | --enc_in 8 \ 136 | --dec_in 8 \ 137 | --c_out 8 \ 138 | --des 'only output' \ 139 | --channel_independent \ 140 | --wd $wd \ 141 | --pred_residual 142 | 143 | # traffic 144 | python -u run.py \ 145 | --is_training 1 \ 146 | --data_path traffic.csv \ 147 | --task_id traffic \ 148 | --model $model \ 149 | --data custom \ 150 | --features M \ 151 | --seq_len 96 \ 152 | --label_len 48 \ 153 | --pred_len $preLen \ 154 | --e_layers 2 \ 155 | --d_layers 1 \ 156 | --factor 3 \ 157 | --enc_in 862 \ 158 | --dec_in 862 \ 159 | --c_out 862 \ 160 | --des 'only output' \ 161 | --channel_independent \ 162 | --wd $wd \ 163 | --pred_residual 164 | 165 | # weather 166 | python -u run.py \ 167 | --is_training 1 \ 168 | --data_path weather.csv \ 169 | --task_id weather \ 170 | --model $model \ 171 | --data custom \ 172 | --features M \ 173 | --seq_len 96 \ 174 | --label_len 48 \ 175 | --pred_len $preLen \ 176 | --e_layers 2 \ 177 | --d_layers 1 \ 178 | --factor 3 \ 179 | --enc_in 21 \ 180 | --dec_in 21 \ 181 | --c_out 21 \ 182 | --des 'only output' \ 183 | --channel_independent \ 184 | --wd $wd \ 185 | --pred_residual 186 | done 187 | 188 | for preLen in 24; do 189 | # illness 190 | python -u run.py \ 191 | --is_training 1 \ 192 | --data_path national_illness.csv \ 193 | --task_id ili \ 194 | --model $model \ 195 | --data custom \ 196 | --features M \ 197 | --seq_len 36 \ 198 | --label_len 18 \ 199 | --pred_len $preLen \ 200 | --e_layers 2 \ 201 | --d_layers 1 \ 202 | --factor 3 \ 203 | --enc_in 7 \ 204 | --dec_in 7 \ 205 | --c_out 7 \ 206 | --des 'only output' \ 207 | --channel_independent \ 208 | --wd $wd \ 209 | --pred_residual 210 | done 211 | done 212 | -------------------------------------------------------------------------------- /scripts/prreg/linear.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=3 2 | model_name=Linear 3 | for wd in 1e-6 1e-5 1e-4 1e-3 1e-2 0.1 1.0; do 4 | for pred_len in 48 96; do 5 | seq_len=96 6 | python -u run.py \ 7 | --is_training 1 \ 8 | --data_path ETTh1.csv \ 9 | --task_id ETTh1_$seq_len'_'$pred_len \ 10 | --model $model_name \ 11 | --data ETTh1 \ 12 | --features M \ 13 | --seq_len $seq_len \ 14 | --pred_len $pred_len \ 15 | --enc_in 7 \ 16 | --des 'PRREG experiemnts' \ 17 | --tags weight_decay \ 18 | --flat_input \ 19 | --wd $wd \ 20 | --pred_residual \ 21 | --batch_size 32 --learning_rate 0.005 22 | 23 | python -u run.py \ 24 | --is_training 1 \ 25 | --data_path ETTh2.csv \ 26 | --task_id ETTh2_$seq_len'_'$pred_len \ 27 | --model $model_name \ 28 | --data ETTh2 \ 29 | --features M \ 30 | --seq_len $seq_len \ 31 | --pred_len $pred_len \ 32 | --enc_in 7 \ 33 | --des 'PRREG experiemnts' \ 34 | --tags weight_decay \ 35 | --flat_input \ 36 | --wd $wd \ 37 | --pred_residual \ 38 | --batch_size 32 --learning_rate 0.05 39 | 40 | python -u run.py \ 41 | --is_training 1 \ 42 | --data_path ETTm1.csv \ 43 | --task_id ETTm1_$seq_len'_'$pred_len \ 44 | --model $model_name \ 45 | --data ETTm1 \ 46 | --features M \ 47 | --seq_len $seq_len \ 48 | --pred_len $pred_len \ 49 | --enc_in 7 \ 50 | --des 'PRREG experiemnts' \ 51 | --tags weight_decay \ 52 | --flat_input \ 53 | --wd $wd \ 54 | --pred_residual \ 55 | --batch_size 8 --learning_rate 0.0001 56 | 57 | python -u run.py \ 58 | --is_training 1 \ 59 | --data_path ETTm2.csv \ 60 | --task_id ETTm2_$seq_len'_'$pred_len \ 61 | --model $model_name \ 62 | --data ETTm2 \ 63 | --features M \ 64 | --seq_len $seq_len \ 65 | --pred_len $pred_len \ 66 | --enc_in 7 \ 67 | --des 'PRREG experiemnts' \ 68 | --tags weight_decay \ 69 | --flat_input \ 70 | --wd $wd \ 71 | --pred_residual \ 72 | --batch_size 32 --learning_rate 0.001 73 | 74 | python -u run.py \ 75 | --is_training 1 \ 76 | --data_path exchange_rate.csv \ 77 | --task_id Exchange_$seq_len'_'$pred_len \ 78 | --model $model_name \ 79 | --data custom \ 80 | --features M \ 81 | --seq_len $seq_len \ 82 | --pred_len $pred_len \ 83 | --enc_in 8 \ 84 | --des 'PRREG experiemnts' \ 85 | --tags weight_decay \ 86 | --flat_input \ 87 | --wd $wd \ 88 | --pred_residual \ 89 | --batch_size 32 --learning_rate 0.0005 90 | 91 | python -u run.py \ 92 | --is_training 1 \ 93 | --data_path weather.csv \ 94 | --task_id weather_$seq_len'_'$pred_len \ 95 | --model $model_name \ 96 | --data custom \ 97 | --features M \ 98 | --seq_len $seq_len \ 99 | --pred_len $pred_len \ 100 | --enc_in 21 \ 101 | --des 'PRREG experiemnts' \ 102 | --tags weight_decay \ 103 | --flat_input \ 104 | --wd $wd \ 105 | --pred_residual \ 106 | --batch_size 32 107 | 108 | # python -u run.py \ 109 | # --is_training 1 \ 110 | # --data_path traffic.csv \ 111 | # --task_id traffic_$seq_len'_'$pred_len \ 112 | # --model $model_name \ 113 | # --data custom \ 114 | # --features M \ 115 | # --seq_len $seq_len \ 116 | # --pred_len $pred_len \ 117 | # --enc_in 862 \ 118 | # --des 'PRREG experiemnts' \ 119 | # --tags weight_decay \ 120 | # --flat_input 121 | # --wd $wd \ 122 | # --pred_residual 123 | # --learning_rate 0.05 124 | # 125 | # python -u run.py \ 126 | # --is_training 1 \ 127 | # --data_path electricity.csv \ 128 | # --task_id Electricity_$seq_len'_'$pred_len \ 129 | # --model $model_name \ 130 | # --data custom \ 131 | # --features M \ 132 | # --seq_len $seq_len \ 133 | # --pred_len $pred_len \ 134 | # --enc_in 321 \ 135 | # --des 'PRREG experiemnts' \ 136 | # --tags weight_decay \ 137 | # --flat_input 138 | # --wd $wd \ 139 | # --pred_residual 140 | # --learning_rate 0.001 141 | done 142 | 143 | for pred_len in 24 36; do 144 | python -u run.py \ 145 | --is_training 1 \ 146 | --data_path national_illness.csv \ 147 | --task_id national_illness_$seq_len'_'$pred_len \ 148 | --model $model_name \ 149 | --data custom \ 150 | --features M \ 151 | --seq_len $seq_len \ 152 | --label_len 18 \ 153 | --pred_len $pred_len \ 154 | --enc_in 7 \ 155 | --des 'PRREG experiemnts' \ 156 | --tags weight_decay \ 157 | --flat_input \ 158 | --wd $wd \ 159 | --pred_residual \ 160 | --batch_size 32 --learning_rate 0.01 161 | done 162 | done 163 | -------------------------------------------------------------------------------- /scripts/prreg/linear_CI.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=3 2 | model_name=Linear 3 | for wd in 1e-6 1e-5 1e-4 1e-3 1e-2 0.1 1.0; do 4 | for pred_len in 48 96; do 5 | seq_len=96 6 | python -u run.py \ 7 | --is_training 1 \ 8 | --data_path ETTh1.csv \ 9 | --task_id ETTh1_$seq_len'_'$pred_len \ 10 | --model $model_name \ 11 | --data ETTh1 \ 12 | --features M \ 13 | --seq_len $seq_len \ 14 | --pred_len $pred_len \ 15 | --enc_in 7 \ 16 | --des 'low rank experiment' \ 17 | --tags weight_decay \ 18 | --flat_input \ 19 | --wd $wd \ 20 | --pred_residual \ 21 | --batch_size 32 --learning_rate 0.005 22 | 23 | python -u run.py \ 24 | --is_training 1 \ 25 | --data_path ETTh2.csv \ 26 | --task_id ETTh2_$seq_len'_'$pred_len \ 27 | --model $model_name \ 28 | --data ETTh2 \ 29 | --features M \ 30 | --seq_len $seq_len \ 31 | --pred_len $pred_len \ 32 | --enc_in 7 \ 33 | --des 'low rank experiment' \ 34 | --tags weight_decay \ 35 | --flat_input \ 36 | --wd $wd \ 37 | --pred_residual \ 38 | --batch_size 32 --learning_rate 0.05 39 | 40 | python -u run.py \ 41 | --is_training 1 \ 42 | --data_path ETTm1.csv \ 43 | --task_id ETTm1_$seq_len'_'$pred_len \ 44 | --model $model_name \ 45 | --data ETTm1 \ 46 | --features M \ 47 | --seq_len $seq_len \ 48 | --pred_len $pred_len \ 49 | --enc_in 7 \ 50 | --des 'low rank experiment' \ 51 | --tags weight_decay \ 52 | --flat_input \ 53 | --wd $wd \ 54 | --pred_residual \ 55 | --batch_size 8 --learning_rate 0.0001 56 | 57 | python -u run.py \ 58 | --is_training 1 \ 59 | --data_path ETTm2.csv \ 60 | --task_id ETTm2_$seq_len'_'$pred_len \ 61 | --model $model_name \ 62 | --data ETTm2 \ 63 | --features M \ 64 | --seq_len $seq_len \ 65 | --pred_len $pred_len \ 66 | --enc_in 7 \ 67 | --des 'low rank experiment' \ 68 | --tags weight_decay \ 69 | --flat_input \ 70 | --wd $wd \ 71 | --pred_residual \ 72 | --batch_size 32 --learning_rate 0.001 73 | 74 | python -u run.py \ 75 | --is_training 1 \ 76 | --data_path exchange_rate.csv \ 77 | --task_id Exchange_$seq_len'_'$pred_len \ 78 | --model $model_name \ 79 | --data custom \ 80 | --features M \ 81 | --seq_len $seq_len \ 82 | --pred_len $pred_len \ 83 | --enc_in 8 \ 84 | --des 'low rank experiment' \ 85 | --tags weight_decay \ 86 | --flat_input \ 87 | --wd $wd \ 88 | --pred_residual \ 89 | --batch_size 32 --learning_rate 0.0005 90 | 91 | python -u run.py \ 92 | --is_training 1 \ 93 | --data_path weather.csv \ 94 | --task_id weather_$seq_len'_'$pred_len \ 95 | --model $model_name \ 96 | --data custom \ 97 | --features M \ 98 | --seq_len $seq_len \ 99 | --pred_len $pred_len \ 100 | --enc_in 21 \ 101 | --des 'low rank experiment' \ 102 | --tags weight_decay \ 103 | --flat_input \ 104 | --wd $wd \ 105 | --pred_residual \ 106 | --batch_size 32 107 | 108 | done 109 | 110 | for pred_len in 24 36; do 111 | python -u run.py \ 112 | --is_training 1 \ 113 | --data_path national_illness.csv \ 114 | --task_id national_illness_$seq_len'_'$pred_len \ 115 | --model $model_name \ 116 | --data custom \ 117 | --features M \ 118 | --seq_len $seq_len \ 119 | --label_len 18 \ 120 | --pred_len $pred_len \ 121 | --enc_in 7 \ 122 | --des 'low rank experiment' \ 123 | --tags weight_decay \ 124 | --flat_input \ 125 | --wd $wd \ 126 | --pred_residual \ 127 | --batch_size 32 --learning_rate 0.01 128 | done 129 | done 130 | -------------------------------------------------------------------------------- /scripts/seq_len/Transformer.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=3 2 | 3 | #cd .. 4 | model=Transformer 5 | 6 | for preLen in 48; do 7 | for seqlen in 48 96 144 192 240 288 336 384 432; do 8 | # ETT m1 9 | python -u run.py \ 10 | --is_training 1 \ 11 | --data_path ETTm1.csv \ 12 | --task_id ETTm1 \ 13 | --model $model \ 14 | --data ETTm1 \ 15 | --features M \ 16 | --seq_len $seqlen \ 17 | --label_len 48 \ 18 | --pred_len $preLen \ 19 | --e_layers 2 \ 20 | --d_layers 1 \ 21 | --factor 3 \ 22 | --enc_in 7 \ 23 | --dec_in 7 \ 24 | --c_out 7 \ 25 | --des 'Exp' \ 26 | --d_model 512 27 | 28 | # ETTh1 29 | python -u run.py \ 30 | --is_training 1 \ 31 | --data_path ETTh1.csv \ 32 | --task_id ETTh1 \ 33 | --model $model \ 34 | --data ETTh1 \ 35 | --features M \ 36 | --seq_len $seqlen \ 37 | --label_len 48 \ 38 | --pred_len $preLen \ 39 | --e_layers 2 \ 40 | --d_layers 1 \ 41 | --factor 3 \ 42 | --enc_in 7 \ 43 | --dec_in 7 \ 44 | --c_out 7 \ 45 | --des 'Exp' \ 46 | --d_model 512 47 | 48 | # ETTm2 49 | python -u run.py \ 50 | --is_training 1 \ 51 | --data_path ETTm2.csv \ 52 | --task_id ETTm2 \ 53 | --model $model \ 54 | --data ETTm2 \ 55 | --features M \ 56 | --seq_len $seqlen \ 57 | --label_len 48 \ 58 | --pred_len $preLen \ 59 | --e_layers 2 \ 60 | --d_layers 1 \ 61 | --factor 3 \ 62 | --enc_in 7 \ 63 | --dec_in 7 \ 64 | --c_out 7 \ 65 | --des 'Exp' \ 66 | --d_model 512 67 | 68 | # ETTh2 69 | python -u run.py \ 70 | --is_training 1 \ 71 | --data_path ETTh2.csv \ 72 | --task_id ETTh2 \ 73 | --model $model \ 74 | --data ETTh2 \ 75 | --features M \ 76 | --seq_len $seqlen \ 77 | --label_len 48 \ 78 | --pred_len $preLen \ 79 | --e_layers 2 \ 80 | --d_layers 1 \ 81 | --factor 3 \ 82 | --enc_in 7 \ 83 | --dec_in 7 \ 84 | --c_out 7 \ 85 | --des 'Exp' \ 86 | --d_model 512 87 | 88 | ## electricity 89 | python -u run.py \ 90 | --is_training 1 \ 91 | --data_path electricity.csv \ 92 | --task_id ECL \ 93 | --model $model \ 94 | --data custom \ 95 | --features M \ 96 | --seq_len $seqlen \ 97 | --label_len 48 \ 98 | --pred_len $preLen \ 99 | --e_layers 2 \ 100 | --d_layers 1 \ 101 | --factor 3 \ 102 | --enc_in 321 \ 103 | --dec_in 321 \ 104 | --c_out 321 \ 105 | --des 'Exp' 106 | 107 | # exchange 108 | python -u run.py \ 109 | --is_training 1 \ 110 | --data_path exchange_rate.csv \ 111 | --task_id Exchange \ 112 | --model $model \ 113 | --data custom \ 114 | --features M \ 115 | --seq_len $seqlen \ 116 | --label_len 48 \ 117 | --pred_len $preLen \ 118 | --e_layers 2 \ 119 | --d_layers 1 \ 120 | --factor 3 \ 121 | --enc_in 8 \ 122 | --dec_in 8 \ 123 | --c_out 8 \ 124 | --des 'Exp' 125 | 126 | # traffic 127 | python -u run.py \ 128 | --is_training 1 \ 129 | --data_path traffic.csv \ 130 | --task_id traffic \ 131 | --model $model \ 132 | --data custom \ 133 | --features M \ 134 | --seq_len $seqlen \ 135 | --label_len 48 \ 136 | --pred_len $preLen \ 137 | --e_layers 2 \ 138 | --d_layers 1 \ 139 | --factor 3 \ 140 | --enc_in 862 \ 141 | --dec_in 862 \ 142 | --c_out 862 \ 143 | --des 'Exp' 144 | 145 | # weather 146 | python -u run.py \ 147 | --is_training 1 \ 148 | --data_path weather.csv \ 149 | --task_id weather \ 150 | --model $model \ 151 | --data custom \ 152 | --features M \ 153 | --seq_len $seqlen \ 154 | --label_len 48 \ 155 | --pred_len $preLen \ 156 | --e_layers 2 \ 157 | --d_layers 1 \ 158 | --factor 3 \ 159 | --enc_in 21 \ 160 | --dec_in 21 \ 161 | --c_out 21 \ 162 | --des 'Exp' 163 | done 164 | for preLen in 24; do 165 | # illness 166 | python -u run.py \ 167 | --is_training 1 \ 168 | --data_path national_illness.csv \ 169 | --task_id ili \ 170 | --model $model \ 171 | --data custom \ 172 | --features M \ 173 | --seq_len 36 \ 174 | --label_len 18 \ 175 | --pred_len $preLen \ 176 | --e_layers 2 \ 177 | --d_layers 1 \ 178 | --factor 3 \ 179 | --enc_in 7 \ 180 | --dec_in 7 \ 181 | --c_out 7 \ 182 | --des 'Exp' 183 | done 184 | done 185 | -------------------------------------------------------------------------------- /scripts/seq_len/Transformer_ci.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=2 2 | 3 | #cd .. 4 | model=Transformer 5 | 6 | for preLen in 48; do 7 | for seqlen in 48 96 144 192 240 288 336 384 432; do 8 | # ETT m1 9 | python -u run.py \ 10 | --is_training 1 \ 11 | --data_path ETTm1.csv \ 12 | --task_id ETTm1 \ 13 | --model $model \ 14 | --data ETTm1 \ 15 | --features M \ 16 | --seq_len $seqlen \ 17 | --label_len 48 \ 18 | --pred_len $preLen \ 19 | --e_layers 2 \ 20 | --d_layers 1 \ 21 | --factor 3 \ 22 | --enc_in 7 \ 23 | --dec_in 7 \ 24 | --c_out 7 \ 25 | --des 'global_dataset' \ 26 | --channel_independent \ 27 | --batch_size 256 \ 28 | --d_model 64 29 | 30 | # ETTh1 31 | python -u run.py \ 32 | --is_training 1 \ 33 | --data_path ETTh1.csv \ 34 | --task_id ETTh1 \ 35 | --model $model \ 36 | --data ETTh1 \ 37 | --features M \ 38 | --seq_len $seqlen \ 39 | --label_len 48 \ 40 | --pred_len $preLen \ 41 | --e_layers 2 \ 42 | --d_layers 1 \ 43 | --factor 3 \ 44 | --enc_in 7 \ 45 | --dec_in 7 \ 46 | --c_out 7 \ 47 | --des 'global_dataset' \ 48 | --channel_independent \ 49 | --batch_size 256 \ 50 | --d_model 64 51 | 52 | # ETTm2 53 | python -u run.py \ 54 | --is_training 1 \ 55 | --data_path ETTm2.csv \ 56 | --task_id ETTm2 \ 57 | --model $model \ 58 | --data ETTm2 \ 59 | --features M \ 60 | --seq_len $seqlen \ 61 | --label_len 48 \ 62 | --pred_len $preLen \ 63 | --e_layers 2 \ 64 | --d_layers 1 \ 65 | --factor 3 \ 66 | --enc_in 7 \ 67 | --dec_in 7 \ 68 | --c_out 7 \ 69 | --des 'global_dataset' \ 70 | --channel_independent \ 71 | --batch_size 256 \ 72 | --d_model 64 73 | 74 | # ETTh2 75 | python -u run.py \ 76 | --is_training 1 \ 77 | --data_path ETTh2.csv \ 78 | --task_id ETTh2 \ 79 | --model $model \ 80 | --data ETTh2 \ 81 | --features M \ 82 | --seq_len $seqlen \ 83 | --label_len 48 \ 84 | --pred_len $preLen \ 85 | --e_layers 2 \ 86 | --d_layers 1 \ 87 | --factor 3 \ 88 | --enc_in 7 \ 89 | --dec_in 7 \ 90 | --c_out 7 \ 91 | --des 'global_dataset' \ 92 | --channel_independent \ 93 | --batch_size 256 \ 94 | --d_model 64 95 | 96 | ## electricity 97 | python -u run.py \ 98 | --is_training 1 \ 99 | --data_path electricity.csv \ 100 | --task_id ECL \ 101 | --model $model \ 102 | --data custom \ 103 | --features M \ 104 | --seq_len $seqlen \ 105 | --label_len 48 \ 106 | --pred_len $preLen \ 107 | --e_layers 2 \ 108 | --d_layers 1 \ 109 | --factor 3 \ 110 | --enc_in 321 \ 111 | --dec_in 321 \ 112 | --c_out 321 \ 113 | --des 'global_dataset' \ 114 | --channel_independent \ 115 | --batch_size 256 \ 116 | --d_model 64 117 | 118 | # exchange 119 | python -u run.py \ 120 | --is_training 1 \ 121 | --data_path exchange_rate.csv \ 122 | --task_id Exchange \ 123 | --model $model \ 124 | --data custom \ 125 | --features M \ 126 | --seq_len $seqlen \ 127 | --label_len 48 \ 128 | --pred_len $preLen \ 129 | --e_layers 2 \ 130 | --d_layers 1 \ 131 | --factor 3 \ 132 | --enc_in 8 \ 133 | --dec_in 8 \ 134 | --c_out 8 \ 135 | --des 'global_dataset' \ 136 | --channel_independent \ 137 | --batch_size 256 \ 138 | --d_model 64 139 | 140 | # traffic 141 | python -u run.py \ 142 | --is_training 1 \ 143 | --data_path traffic.csv \ 144 | --task_id traffic \ 145 | --model $model \ 146 | --data custom \ 147 | --features M \ 148 | --seq_len $seqlen \ 149 | --label_len 48 \ 150 | --pred_len $preLen \ 151 | --e_layers 2 \ 152 | --d_layers 1 \ 153 | --factor 3 \ 154 | --enc_in 862 \ 155 | --dec_in 862 \ 156 | --c_out 862 \ 157 | --des 'global_dataset' \ 158 | --channel_independent \ 159 | --batch_size 256 \ 160 | --d_model 64 161 | 162 | # weather 163 | python -u run.py \ 164 | --is_training 1 \ 165 | --data_path weather.csv \ 166 | --task_id weather \ 167 | --model $model \ 168 | --data custom \ 169 | --features M \ 170 | --seq_len $seqlen \ 171 | --label_len 48 \ 172 | --pred_len $preLen \ 173 | --e_layers 2 \ 174 | --d_layers 1 \ 175 | --factor 3 \ 176 | --enc_in 21 \ 177 | --dec_in 21 \ 178 | --c_out 21 \ 179 | --des 'global_dataset' \ 180 | --channel_independent \ 181 | --batch_size 256 \ 182 | --d_model 64 183 | done 184 | done 185 | 186 | #for preLen in 24 36 48 60; do 187 | # # illness 188 | # python -u run.py \ 189 | # --is_training 1 \ 190 | # --data_path national_illness.csv \ 191 | # --task_id ili \ 192 | # --model $model \ 193 | # --data custom \ 194 | # --features M \ 195 | # --seq_len 36 \ 196 | # --label_len 18 \ 197 | # --pred_len $preLen \ 198 | # --e_layers 2 \ 199 | # --d_layers 1 \ 200 | # --factor 3 \ 201 | # --enc_in 7 \ 202 | # --dec_in 7 \ 203 | # --c_out 7 \ 204 | # --des 'global_dataset' \ 205 | # --channel_independent \ 206 | # --batch_size 64 \ 207 | # --d_model 512 208 | #done 209 | -------------------------------------------------------------------------------- /scripts/seq_len/linear.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=0 2 | model_name=Linear 3 | for seq_len in 48 96 144 192 240 288 336 384 432; do 4 | for pred_len in 48; do 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'low rank experiment' \ 16 | --tags seq_len \ 17 | --flat_input \ 18 | --batch_size 32 --learning_rate 0.005 19 | 20 | python -u run.py \ 21 | --is_training 1 \ 22 | --data_path ETTh2.csv \ 23 | --task_id ETTh2_$seq_len'_'$pred_len \ 24 | --model $model_name \ 25 | --data ETTh2 \ 26 | --features M \ 27 | --seq_len $seq_len \ 28 | --pred_len $pred_len \ 29 | --enc_in 7 \ 30 | --des 'low rank experiment' \ 31 | --tags seq_len \ 32 | --flat_input \ 33 | --batch_size 32 --learning_rate 0.05 34 | 35 | python -u run.py \ 36 | --is_training 1 \ 37 | --data_path ETTm1.csv \ 38 | --task_id ETTm1_$seq_len'_'$pred_len \ 39 | --model $model_name \ 40 | --data ETTm1 \ 41 | --features M \ 42 | --seq_len $seq_len \ 43 | --pred_len $pred_len \ 44 | --enc_in 7 \ 45 | --des 'low rank experiment' \ 46 | --tags seq_len \ 47 | --flat_input \ 48 | --batch_size 8 --learning_rate 0.0001 49 | 50 | python -u run.py \ 51 | --is_training 1 \ 52 | --data_path ETTm2.csv \ 53 | --task_id ETTm2_$seq_len'_'$pred_len \ 54 | --model $model_name \ 55 | --data ETTm2 \ 56 | --features M \ 57 | --seq_len $seq_len \ 58 | --pred_len $pred_len \ 59 | --enc_in 7 \ 60 | --des 'low rank experiment' \ 61 | --tags seq_len \ 62 | --flat_input \ 63 | --batch_size 32 --learning_rate 0.001 64 | 65 | python -u run.py \ 66 | --is_training 1 \ 67 | --data_path exchange_rate.csv \ 68 | --task_id Exchange_$seq_len'_'$pred_len \ 69 | --model $model_name \ 70 | --data custom \ 71 | --features M \ 72 | --seq_len $seq_len \ 73 | --pred_len $pred_len \ 74 | --enc_in 8 \ 75 | --des 'low rank experiment' \ 76 | --tags seq_len \ 77 | --flat_input \ 78 | --batch_size 32 --learning_rate 0.0005 79 | 80 | python -u run.py \ 81 | --is_training 1 \ 82 | --data_path weather.csv \ 83 | --task_id weather_$seq_len'_'$pred_len \ 84 | --model $model_name \ 85 | --data custom \ 86 | --features M \ 87 | --seq_len $seq_len \ 88 | --pred_len $pred_len \ 89 | --enc_in 21 \ 90 | --des 'low rank experiment' \ 91 | --tags seq_len \ 92 | --flat_input \ 93 | --batch_size 32 94 | 95 | python -u run.py \ 96 | --is_training 1 \ 97 | --data_path traffic.csv \ 98 | --task_id traffic_$seq_len'_'$pred_len \ 99 | --model $model_name \ 100 | --data custom \ 101 | --features M \ 102 | --seq_len $seq_len \ 103 | --pred_len $pred_len \ 104 | --enc_in 862 \ 105 | --des 'low rank experiment' \ 106 | --tags seq_len \ 107 | --flat_input \ 108 | --learning_rate 0.05 109 | python -u run.py \ 110 | --is_training 1 \ 111 | --data_path electricity.csv \ 112 | --task_id Electricity_$seq_len'_'$pred_len \ 113 | --model $model_name \ 114 | --data custom \ 115 | --features M \ 116 | --seq_len $seq_len \ 117 | --pred_len $pred_len \ 118 | --enc_in 321 \ 119 | --des 'low rank experiment' \ 120 | --tags seq_len \ 121 | --flat_input \ 122 | --learning_rate 0.001 123 | done 124 | 125 | for pred_len in 24; do 126 | python -u run.py \ 127 | --is_training 1 \ 128 | --data_path national_illness.csv \ 129 | --task_id national_illness_$seq_len'_'$pred_len \ 130 | --model $model_name \ 131 | --data custom \ 132 | --features M \ 133 | --seq_len $seq_len \ 134 | --label_len 18 \ 135 | --pred_len $pred_len \ 136 | --enc_in 7 \ 137 | --des 'low rank experiment' \ 138 | --tags seq_len \ 139 | --flat_input \ 140 | --batch_size 32 --learning_rate 0.01 141 | done 142 | done 143 | -------------------------------------------------------------------------------- /scripts/seq_len/linear_ci.sh: -------------------------------------------------------------------------------- 1 | export CUDA_VISIBLE_DEVICES=1 2 | model_name=Linear 3 | for seq_len in 48 96 144 192 240 288 336 384 432; do 4 | for pred_len in 48; do 5 | python -u run.py \ 6 | --is_training 1 \ 7 | --data_path ETTh1.csv \ 8 | --task_id ETTh1_$seq_len'_'$pred_len \ 9 | --model $model_name \ 10 | --data ETTh1 \ 11 | --features M \ 12 | --seq_len $seq_len \ 13 | --pred_len $pred_len \ 14 | --enc_in 7 \ 15 | --des 'low rank experiment' \ 16 | --tags seq_len \ 17 | --batch_size 32 --learning_rate 0.005 18 | 19 | python -u run.py \ 20 | --is_training 1 \ 21 | --data_path ETTh2.csv \ 22 | --task_id ETTh2_$seq_len'_'$pred_len \ 23 | --model $model_name \ 24 | --data ETTh2 \ 25 | --features M \ 26 | --seq_len $seq_len \ 27 | --pred_len $pred_len \ 28 | --enc_in 7 \ 29 | --des 'low rank experiment' \ 30 | --tags seq_len \ 31 | --batch_size 32 --learning_rate 0.05 32 | 33 | python -u run.py \ 34 | --is_training 1 \ 35 | --data_path ETTm1.csv \ 36 | --task_id ETTm1_$seq_len'_'$pred_len \ 37 | --model $model_name \ 38 | --data ETTm1 \ 39 | --features M \ 40 | --seq_len $seq_len \ 41 | --pred_len $pred_len \ 42 | --enc_in 7 \ 43 | --des 'low rank experiment' \ 44 | --tags seq_len \ 45 | --batch_size 8 --learning_rate 0.0001 46 | 47 | python -u run.py \ 48 | --is_training 1 \ 49 | --data_path ETTm2.csv \ 50 | --task_id ETTm2_$seq_len'_'$pred_len \ 51 | --model $model_name \ 52 | --data ETTm2 \ 53 | --features M \ 54 | --seq_len $seq_len \ 55 | --pred_len $pred_len \ 56 | --enc_in 7 \ 57 | --des 'low rank experiment' \ 58 | --tags seq_len \ 59 | --batch_size 32 --learning_rate 0.001 60 | 61 | python -u run.py \ 62 | --is_training 1 \ 63 | --data_path exchange_rate.csv \ 64 | --task_id Exchange_$seq_len'_'$pred_len \ 65 | --model $model_name \ 66 | --data custom \ 67 | --features M \ 68 | --seq_len $seq_len \ 69 | --pred_len $pred_len \ 70 | --enc_in 8 \ 71 | --des 'low rank experiment' \ 72 | --tags seq_len \ 73 | --batch_size 32 --learning_rate 0.0005 74 | 75 | python -u run.py \ 76 | --is_training 1 \ 77 | --data_path weather.csv \ 78 | --task_id weather_$seq_len'_'$pred_len \ 79 | --model $model_name \ 80 | --data custom \ 81 | --features M \ 82 | --seq_len $seq_len \ 83 | --pred_len $pred_len \ 84 | --enc_in 21 \ 85 | --des 'low rank experiment' \ 86 | --tags seq_len \ 87 | --batch_size 32 88 | 89 | python -u run.py \ 90 | --is_training 1 \ 91 | --data_path traffic.csv \ 92 | --task_id traffic_$seq_len'_'$pred_len \ 93 | --model $model_name \ 94 | --data custom \ 95 | --features M \ 96 | --seq_len $seq_len \ 97 | --pred_len $pred_len \ 98 | --enc_in 862 \ 99 | --des 'low rank experiment' \ 100 | --tags seq_len \ 101 | --flat_input \ 102 | --learning_rate 0.05 103 | 104 | python -u run.py \ 105 | --is_training 1 \ 106 | --data_path electricity.csv \ 107 | --task_id Electricity_$seq_len'_'$pred_len \ 108 | --model $model_name \ 109 | --data custom \ 110 | --features M \ 111 | --seq_len $seq_len \ 112 | --pred_len $pred_len \ 113 | --enc_in 321 \ 114 | --des 'low rank experiment' \ 115 | --tags seq_len \ 116 | --flat_input \ 117 | --learning_rate 0.001 118 | done 119 | 120 | for pred_len in 24; do 121 | python -u run.py \ 122 | --is_training 1 \ 123 | --data_path national_illness.csv \ 124 | --task_id national_illness_$seq_len'_'$pred_len \ 125 | --model $model_name \ 126 | --data custom \ 127 | --features M \ 128 | --seq_len $seq_len \ 129 | --label_len 18 \ 130 | --pred_len $pred_len \ 131 | --enc_in 7 \ 132 | --des 'low rank experiment' \ 133 | --tags seq_len \ 134 | --batch_size 32 --learning_rate 0.01 135 | done 136 | done 137 | -------------------------------------------------------------------------------- /utils/masking.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import numpy as np 3 | import math 4 | 5 | class TriangularCausalMask(): 6 | def __init__(self, B, L, device="cpu"): 7 | mask_shape = [B, 1, L, L] 8 | with torch.no_grad(): 9 | self._mask = torch.triu(torch.ones(mask_shape, dtype=torch.bool), diagonal=1).to(device) 10 | 11 | @property 12 | def mask(self): 13 | return self._mask 14 | 15 | 16 | class ProbMask(): 17 | def __init__(self, B, H, L, index, scores, device="cpu"): 18 | _mask = torch.ones(L, scores.shape[-1], dtype=torch.bool).to(device).triu(1) 19 | _mask_ex = _mask[None, None, :].expand(B, H, L, scores.shape[-1]) 20 | indicator = _mask_ex[torch.arange(B)[:, None, None], 21 | torch.arange(H)[None, :, None], 22 | index, :].to(device) 23 | self._mask = indicator.view(scores.shape).to(device) 24 | 25 | @property 26 | def mask(self): 27 | return self._mask 28 | 29 | class LocalMask(): 30 | def __init__(self, B, L,S,device="cpu"): 31 | mask_shape = [B, 1, L, S] 32 | with torch.no_grad(): 33 | self.len = math.ceil(np.log2(L)) 34 | self._mask1 = torch.triu(torch.ones(mask_shape, dtype=torch.bool), diagonal=1).to(device) 35 | self._mask2 = ~torch.triu(torch.ones(mask_shape,dtype=torch.bool),diagonal=-self.len).to(device) 36 | self._mask = self._mask1+self._mask2 37 | @property 38 | def mask(self): 39 | return self._mask -------------------------------------------------------------------------------- /utils/metrics.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | 3 | 4 | def RSE(pred, true): 5 | return np.sqrt(np.sum((true - pred) ** 2)) / np.sqrt(np.sum((true - true.mean()) ** 2)) 6 | 7 | 8 | def CORR(pred, true): 9 | u = ((true - true.mean(0)) * (pred - pred.mean(0))).sum(0) 10 | d = np.sqrt(((true - true.mean(0)) ** 2 * (pred - pred.mean(0)) ** 2).sum(0)) 11 | return (u / d).mean(-1) 12 | 13 | 14 | def MAE(pred, true): 15 | return np.mean(np.abs(pred - true)) 16 | 17 | 18 | def MSE(pred, true): 19 | return np.mean((pred - true) ** 2) 20 | 21 | 22 | def RMSE(pred, true): 23 | return np.sqrt(MSE(pred, true)) 24 | 25 | 26 | def MAPE(pred, true): 27 | return np.mean(np.abs((pred - true) / true)) 28 | 29 | 30 | def MSPE(pred, true): 31 | return np.mean(np.square((pred - true) / true)) 32 | 33 | 34 | def metric(pred, true): 35 | mae = MAE(pred, true) 36 | mse = MSE(pred, true) 37 | rmse = RMSE(pred, true) 38 | mape = MAPE(pred, true) 39 | mspe = MSPE(pred, true) 40 | 41 | return mae, mse, rmse, mape, mspe 42 | -------------------------------------------------------------------------------- /utils/timefeatures.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | import numpy as np 4 | import pandas as pd 5 | from pandas.tseries import offsets 6 | from pandas.tseries.frequencies import to_offset 7 | 8 | 9 | class TimeFeature: 10 | def __init__(self): 11 | pass 12 | 13 | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: 14 | pass 15 | 16 | def __repr__(self): 17 | return self.__class__.__name__ + "()" 18 | 19 | 20 | class SecondOfMinute(TimeFeature): 21 | """Minute of hour encoded as value between [-0.5, 0.5]""" 22 | 23 | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: 24 | return index.second / 59.0 - 0.5 25 | 26 | 27 | class MinuteOfHour(TimeFeature): 28 | """Minute of hour encoded as value between [-0.5, 0.5]""" 29 | 30 | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: 31 | return index.minute / 59.0 - 0.5 32 | 33 | 34 | class HourOfDay(TimeFeature): 35 | """Hour of day encoded as value between [-0.5, 0.5]""" 36 | 37 | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: 38 | return index.hour / 23.0 - 0.5 39 | 40 | 41 | class DayOfWeek(TimeFeature): 42 | """Hour of day encoded as value between [-0.5, 0.5]""" 43 | 44 | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: 45 | return index.dayofweek / 6.0 - 0.5 46 | 47 | 48 | class DayOfMonth(TimeFeature): 49 | """Day of month encoded as value between [-0.5, 0.5]""" 50 | 51 | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: 52 | return (index.day - 1) / 30.0 - 0.5 53 | 54 | 55 | class DayOfYear(TimeFeature): 56 | """Day of year encoded as value between [-0.5, 0.5]""" 57 | 58 | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: 59 | return (index.dayofyear - 1) / 365.0 - 0.5 60 | 61 | 62 | class MonthOfYear(TimeFeature): 63 | """Month of year encoded as value between [-0.5, 0.5]""" 64 | 65 | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: 66 | return (index.month - 1) / 11.0 - 0.5 67 | 68 | 69 | class WeekOfYear(TimeFeature): 70 | """Week of year encoded as value between [-0.5, 0.5]""" 71 | 72 | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: 73 | return (index.isocalendar().week - 1) / 52.0 - 0.5 74 | 75 | 76 | def time_features_from_frequency_str(freq_str: str) -> List[TimeFeature]: 77 | """ 78 | Returns a list of time features that will be appropriate for the given frequency string. 79 | Parameters 80 | ---------- 81 | freq_str 82 | Frequency string of the form [multiple][granularity] such as "12H", "5min", "1D" etc. 83 | """ 84 | 85 | features_by_offsets = { 86 | offsets.YearEnd: [], 87 | offsets.QuarterEnd: [MonthOfYear], 88 | offsets.MonthEnd: [MonthOfYear], 89 | offsets.Week: [DayOfMonth, WeekOfYear], 90 | offsets.Day: [DayOfWeek, DayOfMonth, DayOfYear], 91 | offsets.BusinessDay: [DayOfWeek, DayOfMonth, DayOfYear], 92 | offsets.Hour: [HourOfDay, DayOfWeek, DayOfMonth, DayOfYear], 93 | offsets.Minute: [ 94 | MinuteOfHour, 95 | HourOfDay, 96 | DayOfWeek, 97 | DayOfMonth, 98 | DayOfYear, 99 | ], 100 | offsets.Second: [ 101 | SecondOfMinute, 102 | MinuteOfHour, 103 | HourOfDay, 104 | DayOfWeek, 105 | DayOfMonth, 106 | DayOfYear, 107 | ], 108 | } 109 | 110 | offset = to_offset(freq_str) 111 | 112 | for offset_type, feature_classes in features_by_offsets.items(): 113 | if isinstance(offset, offset_type): 114 | return [cls() for cls in feature_classes] 115 | 116 | supported_freq_msg = f""" 117 | Unsupported frequency {freq_str} 118 | The following frequencies are supported: 119 | Y - yearly 120 | alias: A 121 | M - monthly 122 | W - weekly 123 | D - daily 124 | B - business days 125 | H - hourly 126 | T - minutely 127 | alias: min 128 | S - secondly 129 | """ 130 | raise RuntimeError(supported_freq_msg) 131 | 132 | 133 | def time_features(dates, freq='h'): 134 | return np.vstack([feat(dates) for feat in time_features_from_frequency_str(freq)]) 135 | -------------------------------------------------------------------------------- /utils/tools.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import torch 3 | import matplotlib.pyplot as plt 4 | 5 | plt.switch_backend('agg') 6 | 7 | 8 | def adjust_learning_rate(optimizer, epoch, args): 9 | # lr = args.learning_rate * (0.2 ** (epoch // 2)) 10 | if args.lradj == 'type1': 11 | lr_adjust = {epoch: args.learning_rate * (0.5 ** ((epoch - 1) // 1))} 12 | elif args.lradj == 'type2': 13 | lr_adjust = { 14 | 2: 5e-5, 4: 1e-5, 6: 5e-6, 8: 1e-6, 15 | 10: 5e-7, 15: 1e-7, 20: 5e-8 16 | } 17 | elif args.lradj =='type3': 18 | lr_adjust = {epoch: args.learning_rate} 19 | elif args.lradj == 'type4': 20 | lr_adjust = {epoch: args.learning_rate * (0.9 ** ((epoch - 1) // 1))} 21 | if epoch in lr_adjust.keys(): 22 | lr = lr_adjust[epoch] 23 | for param_group in optimizer.param_groups: 24 | param_group['lr'] = lr 25 | print('Updating learning rate to {}'.format(lr)) 26 | 27 | 28 | class EarlyStopping: 29 | def __init__(self, patience=7, verbose=False, delta=0): 30 | self.patience = patience 31 | self.verbose = verbose 32 | self.counter = 0 33 | self.best_score = None 34 | self.early_stop = False 35 | self.val_loss_min = np.Inf 36 | self.delta = delta 37 | 38 | def __call__(self, val_loss, model, path): 39 | score = -val_loss 40 | if self.best_score is None: 41 | self.best_score = score 42 | self.save_checkpoint(val_loss, model, path) 43 | elif score < self.best_score + self.delta: 44 | self.counter += 1 45 | print(f'EarlyStopping counter: {self.counter} out of {self.patience}') 46 | if self.counter >= self.patience: 47 | self.early_stop = True 48 | else: 49 | self.best_score = score 50 | self.save_checkpoint(val_loss, model, path) 51 | self.counter = 0 52 | 53 | def save_checkpoint(self, val_loss, model, path): 54 | if self.verbose: 55 | print(f'Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}). Saving model ...') 56 | torch.save(model.state_dict(), path + '/' + 'checkpoint.pth') 57 | self.val_loss_min = val_loss 58 | 59 | 60 | class dotdict(dict): 61 | """dot.notation access to dictionary attributes""" 62 | __getattr__ = dict.get 63 | __setattr__ = dict.__setitem__ 64 | __delattr__ = dict.__delitem__ 65 | 66 | 67 | class StandardScaler(): 68 | def __init__(self, mean, std): 69 | self.mean = mean 70 | self.std = std 71 | 72 | def transform(self, data): 73 | return (data - self.mean) / self.std 74 | 75 | def inverse_transform(self, data): 76 | return (data * self.std) + self.mean 77 | 78 | 79 | def visual(true, preds=None, name='./pic/test.pdf'): 80 | """ 81 | Results visualization 82 | """ 83 | plt.figure() 84 | plt.plot(true, label='GroundTruth', linewidth=2) 85 | if preds is not None: 86 | plt.plot(preds, label='Prediction', linewidth=2) 87 | plt.legend() 88 | plt.savefig(name, bbox_inches='tight') 89 | --------------------------------------------------------------------------------