pax_global_header00006660000000000000000000000064144335550220014515gustar00rootroot0000000000000052 comment=5e2e8874a5492a7997a5e0e79d7e5ba997888737 library/000077500000000000000000000000001443355502200125255ustar00rootroot00000000000000library/.gitignore000066400000000000000000000045541443355502200145250ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ pip-wheel-metadata/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # PEP 582; used by e.g. github.com/David-OConnor/pyflow __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ /scripts/long_term_forecast/Traffic_script/PatchTST1.sh /backups/ /result.xlsx /~$result.xlsx /Time-Series-Library.zip /temp.sh .idea /tv_result.xlsx /test.py /m4_results/ /test_results/ /PatchTST_results.xlsx /seq_len_long_term_forecast/ /progress.xlsx /scripts/short_term_forecast/PatchTST_M4.sh /run_tv.py /scripts/long_term_forecast/ETT_tv_script/ /dataset/ data_factory_all.py data_loader_all.py /scripts/short_term_forecast/tv_script/ /exp/exp_short_term_forecasting_tv.py /exp/exp_long_term_forecasting_tv.py /timesnetv2.xlsx /scripts/anomaly_detection/tmp/ /scripts/imputation/tmp/ /utils/self_tools.py library/LICENSE000066400000000000000000000020741443355502200135350ustar00rootroot00000000000000MIT License Copyright (c) 2021 THUML @ Tsinghua University Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. library/README.md000066400000000000000000000220061443355502200140040ustar00rootroot00000000000000# Time Series Library (TSlib) TSlib is an open-source library for deep learning researchers, especially deep time series analysis. We provide a neat code base to evaluate advanced deep time series models or develop your own model, which covers five mainstream tasks: **long- and short-term forecasting, imputation, anomaly detection, and classification.** ## Leaderboard for Time Series Analysis Till February 2023, the top three models for five different tasks are: | Model
Ranking | Long-term
Forecasting | Short-term
Forecasting | Imputation | Anomaly
Detection | Classification | | ---------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ | -------------------------------------------------- | | 🥇 1st | [TimesNet](https://arxiv.org/abs/2210.02186) | [TimesNet](https://arxiv.org/abs/2210.02186) | [TimesNet](https://arxiv.org/abs/2210.02186) | [TimesNet](https://arxiv.org/abs/2210.02186) | [TimesNet](https://arxiv.org/abs/2210.02186) | | 🥈 2nd | [DLinear](https://github.com/cure-lab/LTSF-Linear) | [Non-stationary
Transformer](https://github.com/thuml/Nonstationary_Transformers) | [Non-stationary
Transformer](https://github.com/thuml/Nonstationary_Transformers) | [Non-stationary
Transformer](https://github.com/thuml/Nonstationary_Transformers) | [FEDformer](https://github.com/MAZiqing/FEDformer) | | 🥉 3rd | [Non-stationary
Transformer](https://github.com/thuml/Nonstationary_Transformers) | [FEDformer](https://github.com/MAZiqing/FEDformer) | [Autoformer](https://github.com/thuml/Autoformer) | [Informer](https://github.com/zhouhaoyi/Informer2020) | [Autoformer](https://github.com/thuml/Autoformer) | **Note: We will keep updating this leaderborad.** If you have proposed advanced and awesome models, welcome to send your paper/code link to us or raise a pull request. We will add them to this repo and update the leaderborad as soon as possible. **Compared models of this leaderboard.** ☑ means that their codes have already been included in this repo. - [x] **TimesNet** - TimesNet: Temporal 2D-Variation Modeling for General Time Series Analysis [[ICLR 2023]](https://openreview.net/pdf?id=ju_Uqw384Oq) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/TimesNet.py) - [x] **DLinear** - Are Transformers Effective for Time Series Forecasting? [[AAAI 2023]](https://arxiv.org/pdf/2205.13504.pdf) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/DLinear.py) - [x] **LightTS** - Less Is More: Fast Multivariate Time Series Forecasting with Light Sampling-oriented MLP Structures [[arXiv 2022]](https://arxiv.org/abs/2207.01186) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/LightTS.py) - [x] **ETSformer** - ETSformer: Exponential Smoothing Transformers for Time-series Forecasting [[arXiv 2022]](https://arxiv.org/abs/2202.01381) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/ETSformer.py) - [x] **Non-stationary Transformer** - Non-stationary Transformers: Exploring the Stationarity in Time Series Forecasting [[NeurIPS 2022]](https://openreview.net/pdf?id=ucNDIDRNjjv) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/Nonstationary_Transformer.py) - [x] **FEDformer** - FEDformer: Frequency Enhanced Decomposed Transformer for Long-term Series Forecasting [[ICML 2022]](https://proceedings.mlr.press/v162/zhou22g.html) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/FEDformer.py) - [x] **Pyraformer** - Pyraformer: Low-complexity Pyramidal Attention for Long-range Time Series Modeling and Forecasting [[ICLR 2022]](https://openreview.net/pdf?id=0EXmFzUn5I) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/Pyraformer.py) - [x] **Autoformer** - Autoformer: Decomposition Transformers with Auto-Correlation for Long-Term Series Forecasting [[NeurIPS 2021]](https://openreview.net/pdf?id=I55UqU-M11y) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/Autoformer.py) - [x] **Informer** - Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting [[AAAI 2021]](https://ojs.aaai.org/index.php/AAAI/article/view/17325/17132) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/Informer.py) - [x] **Reformer** - Reformer: The Efficient Transformer [[ICLR 2020]](https://openreview.net/forum?id=rkgNKkHtvB) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/Reformer.py) - [x] **Transformer** - Attention is All You Need [[NeurIPS 2017]](https://proceedings.neurips.cc/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/Transformer.py) See our latest paper [[TimesNet]](https://arxiv.org/abs/2210.02186) for the comprehensive benchmark. We will release a real-time updated online version soon. **Newly added baselines.** We will add them into the leaderboard after a comprehensive evaluation. - [x] **FiLM** - FiLM: Frequency improved Legendre Memory Model for Long-term Time Series Forecasting [[NeurIPS 2022]](https://openreview.net/forum?id=zTQdHSQUQWc)[[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/FiLM.py) - [x] **PatchTST** - A Time Series is Worth 64 Words: Long-term Forecasting with Transformers. [[ICLR 2023]](https://openreview.net/pdf?id=Jbdc0vTOcol) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/PatchTST.py) - [x] **MICN** - MICN: Multi-scale Local and Global Context Modeling for Long-term Series Forecasting [[ICLR 2023]](https://openreview.net/pdf?id=zt53IDUR1U)[[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/MICN.py) - [x] **Crossformer** - Crossformer: Transformer Utilizing Cross-Dimension Dependency for Multivariate Time Series Forecasting [[ICLR 2023]](https://openreview.net/pdf?id=vSVLM2j9eie)[[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/Crossformer.py) ## Usage 1. Install Python 3.8. For convenience, execute the following command. ``` pip install -r requirements.txt ``` 2. Prepare Data. You can obtained the well pre-processed datasets from [[Google Drive]](https://drive.google.com/drive/folders/13Cg1KYOlzM5C7K8gK8NfC-F3EYxkM3D2?usp=sharing), [[Tsinghua Cloud]](https://cloud.tsinghua.edu.cn/f/84fbc752d0e94980a610/) or [[Baidu Drive]](https://pan.baidu.com/s/1r3KhGd0Q9PJIUZdfEYoymg?pwd=i9iy). Then place the downloaded data under the folder `./dataset`. Here is a summary of supported datasets.

3. Train and evaluate model. We provide the experiment scripts of all benchmarks under the folder `./scripts/`. You can reproduce the experiment results as the following examples: ``` # long-term forecast bash ./scripts/long_term_forecast/ETT_script/TimesNet_ETTh1.sh # short-term forecast bash ./scripts/short_term_forecast/TimesNet_M4.sh # imputation bash ./scripts/imputation/ETT_script/TimesNet_ETTh1.sh # anomaly detection bash ./scripts/anomaly_detection/PSM/TimesNet.sh # classification bash ./scripts/classification/TimesNet.sh ``` 4. Develop your own model. - Add the model file to the folder `./models`. You can follow the `./models/Transformer.py`. - Include the newly added model in the `Exp_Basic.model_dict` of `./exp/exp_basic.py`. - Create the corresponding scripts under the folder `./scripts`. ## Citation If you find this repo useful, please cite our paper. ``` @inproceedings{wu2023timesnet, title={TimesNet: Temporal 2D-Variation Modeling for General Time Series Analysis}, author={Haixu Wu and Tengge Hu and Yong Liu and Hang Zhou and Jianmin Wang and Mingsheng Long}, booktitle={International Conference on Learning Representations}, year={2023}, } ``` ## Contact If you have any questions or suggestions, feel free to contact: - Haixu Wu (whx20@mails.tsinghua.edu.cn) - Tengge Hu (htg21@mails.tsinghua.edu.cn) - Haoran Zhang (z-hr20@mails.tsinghua.edu.cn) or describe it in Issues. ## Acknowledgement This library is constructed based on the following repos: - Forecasting: https://github.com/thuml/Autoformer - Anomaly Detection: https://github.com/thuml/Anomaly-Transformer - Classification: https://github.com/thuml/Flowformer All the experiment datasets are public and we obtain them from the following links: - Long-term Forecasting and Imputation: https://github.com/thuml/Autoformer - Short-term Forecasting: https://github.com/ServiceNow/N-BEATS - Anomaly Detection: https://github.com/thuml/Anomaly-Transformer - Classification: https://www.timeseriesclassification.com/ library/data_provider/000077500000000000000000000000001443355502200153505ustar00rootroot00000000000000library/data_provider/__init__.py000066400000000000000000000000011443355502200174500ustar00rootroot00000000000000 library/data_provider/data_factory.py000066400000000000000000000054471443355502200203740ustar00rootroot00000000000000from data_provider.data_loader import Dataset_ETT_hour, Dataset_ETT_minute, Dataset_Custom, Dataset_M4, PSMSegLoader, \ MSLSegLoader, SMAPSegLoader, SMDSegLoader, SWATSegLoader, UEAloader from data_provider.uea import collate_fn from torch.utils.data import DataLoader data_dict = { 'ETTh1': Dataset_ETT_hour, 'ETTh2': Dataset_ETT_hour, 'ETTm1': Dataset_ETT_minute, 'ETTm2': Dataset_ETT_minute, 'custom': Dataset_Custom, 'm4': Dataset_M4, 'PSM': PSMSegLoader, 'MSL': MSLSegLoader, 'SMAP': SMAPSegLoader, 'SMD': SMDSegLoader, 'SWAT': SWATSegLoader, 'UEA': UEAloader } def data_provider(args, flag): Data = data_dict[args.data] timeenc = 0 if args.embed != 'timeF' else 1 if flag == 'test': shuffle_flag = False drop_last = True if args.task_name == 'anomaly_detection' or args.task_name == 'classification': batch_size = args.batch_size else: batch_size = 1 # bsz=1 for evaluation freq = args.freq else: shuffle_flag = True drop_last = True batch_size = args.batch_size # bsz for train and valid freq = args.freq if args.task_name == 'anomaly_detection': drop_last = False data_set = Data( root_path=args.root_path, win_size=args.seq_len, flag=flag, ) print(flag, len(data_set)) data_loader = DataLoader( data_set, batch_size=batch_size, shuffle=shuffle_flag, num_workers=args.num_workers, drop_last=drop_last) return data_set, data_loader elif args.task_name == 'classification': drop_last = False data_set = Data( root_path=args.root_path, flag=flag, ) data_loader = DataLoader( data_set, batch_size=batch_size, shuffle=shuffle_flag, num_workers=args.num_workers, drop_last=drop_last, collate_fn=lambda x: collate_fn(x, max_len=args.seq_len) ) return data_set, data_loader else: if args.data == 'm4': drop_last = False data_set = Data( root_path=args.root_path, data_path=args.data_path, flag=flag, size=[args.seq_len, args.label_len, args.pred_len], features=args.features, target=args.target, timeenc=timeenc, freq=freq, seasonal_patterns=args.seasonal_patterns ) print(flag, len(data_set)) data_loader = DataLoader( data_set, batch_size=batch_size, shuffle=shuffle_flag, num_workers=args.num_workers, drop_last=drop_last) return data_set, data_loader library/data_provider/data_loader.py000066400000000000000000000737771443355502200202060ustar00rootroot00000000000000import os import numpy as np import pandas as pd import glob import re import torch from torch.utils.data import Dataset, DataLoader from sklearn.preprocessing import StandardScaler from utils.timefeatures import time_features from data_provider.m4 import M4Dataset, M4Meta from data_provider.uea import subsample, interpolate_missing, Normalizer from sktime.datasets import load_from_tsfile_to_dataframe import warnings warnings.filterwarnings('ignore') class Dataset_ETT_hour(Dataset): def __init__(self, root_path, flag='train', size=None, features='S', data_path='ETTh1.csv', target='OT', scale=True, timeenc=0, freq='h', seasonal_patterns=None): # size [seq_len, label_len, pred_len] # info if size == None: self.seq_len = 24 * 4 * 4 self.label_len = 24 * 4 self.pred_len = 24 * 4 else: self.seq_len = size[0] self.label_len = size[1] self.pred_len = size[2] # init assert flag in ['train', 'test', 'val'] type_map = {'train': 0, 'val': 1, 'test': 2} self.set_type = type_map[flag] self.features = features self.target = target self.scale = scale self.timeenc = timeenc self.freq = freq self.root_path = root_path self.data_path = data_path self.__read_data__() def __read_data__(self): self.scaler = StandardScaler() df_raw = pd.read_csv(os.path.join(self.root_path, self.data_path)) border1s = [0, 12 * 30 * 24 - self.seq_len, 12 * 30 * 24 + 4 * 30 * 24 - self.seq_len] border2s = [12 * 30 * 24, 12 * 30 * 24 + 4 * 30 * 24, 12 * 30 * 24 + 8 * 30 * 24] border1 = border1s[self.set_type] border2 = border2s[self.set_type] if self.features == 'M' or self.features == 'MS': cols_data = df_raw.columns[1:] df_data = df_raw[cols_data] elif self.features == 'S': df_data = df_raw[[self.target]] if self.scale: train_data = df_data[border1s[0]:border2s[0]] self.scaler.fit(train_data.values) data = self.scaler.transform(df_data.values) else: data = df_data.values df_stamp = df_raw[['date']][border1:border2] df_stamp['date'] = pd.to_datetime(df_stamp.date) if self.timeenc == 0: df_stamp['month'] = df_stamp.date.apply(lambda row: row.month, 1) df_stamp['day'] = df_stamp.date.apply(lambda row: row.day, 1) df_stamp['weekday'] = df_stamp.date.apply(lambda row: row.weekday(), 1) df_stamp['hour'] = df_stamp.date.apply(lambda row: row.hour, 1) data_stamp = df_stamp.drop(['date'], 1).values elif self.timeenc == 1: data_stamp = time_features(pd.to_datetime(df_stamp['date'].values), freq=self.freq) data_stamp = data_stamp.transpose(1, 0) self.data_x = data[border1:border2] self.data_y = data[border1:border2] self.data_stamp = data_stamp def __getitem__(self, index): s_begin = index s_end = s_begin + self.seq_len r_begin = s_end - self.label_len r_end = r_begin + self.label_len + self.pred_len seq_x = self.data_x[s_begin:s_end] seq_y = self.data_y[r_begin:r_end] seq_x_mark = self.data_stamp[s_begin:s_end] seq_y_mark = self.data_stamp[r_begin:r_end] return seq_x, seq_y, seq_x_mark, seq_y_mark def __len__(self): return len(self.data_x) - self.seq_len - self.pred_len + 1 def inverse_transform(self, data): return self.scaler.inverse_transform(data) class Dataset_ETT_minute(Dataset): def __init__(self, root_path, flag='train', size=None, features='S', data_path='ETTm1.csv', target='OT', scale=True, timeenc=0, freq='t', seasonal_patterns=None): # size [seq_len, label_len, pred_len] # info if size == None: self.seq_len = 24 * 4 * 4 self.label_len = 24 * 4 self.pred_len = 24 * 4 else: self.seq_len = size[0] self.label_len = size[1] self.pred_len = size[2] # init assert flag in ['train', 'test', 'val'] type_map = {'train': 0, 'val': 1, 'test': 2} self.set_type = type_map[flag] self.features = features self.target = target self.scale = scale self.timeenc = timeenc self.freq = freq self.root_path = root_path self.data_path = data_path self.__read_data__() def __read_data__(self): self.scaler = StandardScaler() df_raw = pd.read_csv(os.path.join(self.root_path, self.data_path)) border1s = [0, 12 * 30 * 24 * 4 - self.seq_len, 12 * 30 * 24 * 4 + 4 * 30 * 24 * 4 - self.seq_len] border2s = [12 * 30 * 24 * 4, 12 * 30 * 24 * 4 + 4 * 30 * 24 * 4, 12 * 30 * 24 * 4 + 8 * 30 * 24 * 4] border1 = border1s[self.set_type] border2 = border2s[self.set_type] if self.features == 'M' or self.features == 'MS': cols_data = df_raw.columns[1:] df_data = df_raw[cols_data] elif self.features == 'S': df_data = df_raw[[self.target]] if self.scale: train_data = df_data[border1s[0]:border2s[0]] self.scaler.fit(train_data.values) data = self.scaler.transform(df_data.values) else: data = df_data.values df_stamp = df_raw[['date']][border1:border2] df_stamp['date'] = pd.to_datetime(df_stamp.date) if self.timeenc == 0: df_stamp['month'] = df_stamp.date.apply(lambda row: row.month, 1) df_stamp['day'] = df_stamp.date.apply(lambda row: row.day, 1) df_stamp['weekday'] = df_stamp.date.apply(lambda row: row.weekday(), 1) df_stamp['hour'] = df_stamp.date.apply(lambda row: row.hour, 1) df_stamp['minute'] = df_stamp.date.apply(lambda row: row.minute, 1) df_stamp['minute'] = df_stamp.minute.map(lambda x: x // 15) data_stamp = df_stamp.drop(['date'], 1).values elif self.timeenc == 1: data_stamp = time_features(pd.to_datetime(df_stamp['date'].values), freq=self.freq) data_stamp = data_stamp.transpose(1, 0) self.data_x = data[border1:border2] self.data_y = data[border1:border2] self.data_stamp = data_stamp def __getitem__(self, index): s_begin = index s_end = s_begin + self.seq_len r_begin = s_end - self.label_len r_end = r_begin + self.label_len + self.pred_len seq_x = self.data_x[s_begin:s_end] seq_y = self.data_y[r_begin:r_end] seq_x_mark = self.data_stamp[s_begin:s_end] seq_y_mark = self.data_stamp[r_begin:r_end] return seq_x, seq_y, seq_x_mark, seq_y_mark def __len__(self): return len(self.data_x) - self.seq_len - self.pred_len + 1 def inverse_transform(self, data): return self.scaler.inverse_transform(data) class Dataset_Custom(Dataset): def __init__(self, root_path, flag='train', size=None, features='S', data_path='ETTh1.csv', target='OT', scale=True, timeenc=0, freq='h', seasonal_patterns=None): # size [seq_len, label_len, pred_len] # info if size == None: self.seq_len = 24 * 4 * 4 self.label_len = 24 * 4 self.pred_len = 24 * 4 else: self.seq_len = size[0] self.label_len = size[1] self.pred_len = size[2] # init assert flag in ['train', 'test', 'val'] type_map = {'train': 0, 'val': 1, 'test': 2} self.set_type = type_map[flag] self.features = features self.target = target self.scale = scale self.timeenc = timeenc self.freq = freq self.root_path = root_path self.data_path = data_path self.__read_data__() def __read_data__(self): self.scaler = StandardScaler() df_raw = pd.read_csv(os.path.join(self.root_path, self.data_path)) ''' df_raw.columns: ['date', ...(other features), target feature] ''' cols = list(df_raw.columns) cols.remove(self.target) cols.remove('date') df_raw = df_raw[['date'] + cols + [self.target]] num_train = int(len(df_raw) * 0.7) num_test = int(len(df_raw) * 0.2) num_vali = len(df_raw) - num_train - num_test border1s = [0, num_train - self.seq_len, len(df_raw) - num_test - self.seq_len] border2s = [num_train, num_train + num_vali, len(df_raw)] border1 = border1s[self.set_type] border2 = border2s[self.set_type] if self.features == 'M' or self.features == 'MS': cols_data = df_raw.columns[1:] df_data = df_raw[cols_data] elif self.features == 'S': df_data = df_raw[[self.target]] if self.scale: train_data = df_data[border1s[0]:border2s[0]] self.scaler.fit(train_data.values) data = self.scaler.transform(df_data.values) else: data = df_data.values df_stamp = df_raw[['date']][border1:border2] df_stamp['date'] = pd.to_datetime(df_stamp.date) if self.timeenc == 0: df_stamp['month'] = df_stamp.date.apply(lambda row: row.month, 1) df_stamp['day'] = df_stamp.date.apply(lambda row: row.day, 1) df_stamp['weekday'] = df_stamp.date.apply(lambda row: row.weekday(), 1) df_stamp['hour'] = df_stamp.date.apply(lambda row: row.hour, 1) data_stamp = df_stamp.drop(['date'], 1).values elif self.timeenc == 1: data_stamp = time_features(pd.to_datetime(df_stamp['date'].values), freq=self.freq) data_stamp = data_stamp.transpose(1, 0) self.data_x = data[border1:border2] self.data_y = data[border1:border2] self.data_stamp = data_stamp def __getitem__(self, index): s_begin = index s_end = s_begin + self.seq_len r_begin = s_end - self.label_len r_end = r_begin + self.label_len + self.pred_len seq_x = self.data_x[s_begin:s_end] seq_y = self.data_y[r_begin:r_end] seq_x_mark = self.data_stamp[s_begin:s_end] seq_y_mark = self.data_stamp[r_begin:r_end] return seq_x, seq_y, seq_x_mark, seq_y_mark def __len__(self): return len(self.data_x) - self.seq_len - self.pred_len + 1 def inverse_transform(self, data): return self.scaler.inverse_transform(data) class Dataset_M4(Dataset): def __init__(self, root_path, flag='pred', size=None, features='S', data_path='ETTh1.csv', target='OT', scale=False, inverse=False, timeenc=0, freq='15min', seasonal_patterns='Yearly'): # size [seq_len, label_len, pred_len] # init self.features = features self.target = target self.scale = scale self.inverse = inverse self.timeenc = timeenc self.root_path = root_path self.seq_len = size[0] self.label_len = size[1] self.pred_len = size[2] self.seasonal_patterns = seasonal_patterns self.history_size = M4Meta.history_size[seasonal_patterns] self.window_sampling_limit = int(self.history_size * self.pred_len) self.flag = flag self.__read_data__() def __read_data__(self): # M4Dataset.initialize() if self.flag == 'train': dataset = M4Dataset.load(training=True, dataset_file=self.root_path) else: dataset = M4Dataset.load(training=False, dataset_file=self.root_path) training_values = np.array( [v[~np.isnan(v)] for v in dataset.values[dataset.groups == self.seasonal_patterns]]) # split different frequencies self.ids = np.array([i for i in dataset.ids[dataset.groups == self.seasonal_patterns]]) self.timeseries = [ts for ts in training_values] def __getitem__(self, index): insample = np.zeros((self.seq_len, 1)) insample_mask = np.zeros((self.seq_len, 1)) outsample = np.zeros((self.pred_len + self.label_len, 1)) outsample_mask = np.zeros((self.pred_len + self.label_len, 1)) # m4 dataset sampled_timeseries = self.timeseries[index] cut_point = np.random.randint(low=max(1, len(sampled_timeseries) - self.window_sampling_limit), high=len(sampled_timeseries), size=1)[0] insample_window = sampled_timeseries[max(0, cut_point - self.seq_len):cut_point] insample[-len(insample_window):, 0] = insample_window insample_mask[-len(insample_window):, 0] = 1.0 outsample_window = sampled_timeseries[ cut_point - self.label_len:min(len(sampled_timeseries), cut_point + self.pred_len)] outsample[:len(outsample_window), 0] = outsample_window outsample_mask[:len(outsample_window), 0] = 1.0 return insample, outsample, insample_mask, outsample_mask def __len__(self): return len(self.timeseries) def inverse_transform(self, data): return self.scaler.inverse_transform(data) def last_insample_window(self): """ The last window of insample size of all timeseries. This function does not support batching and does not reshuffle timeseries. :return: Last insample window of all timeseries. Shape "timeseries, insample size" """ insample = np.zeros((len(self.timeseries), self.seq_len)) insample_mask = np.zeros((len(self.timeseries), self.seq_len)) for i, ts in enumerate(self.timeseries): ts_last_window = ts[-self.seq_len:] insample[i, -len(ts):] = ts_last_window insample_mask[i, -len(ts):] = 1.0 return insample, insample_mask class PSMSegLoader(Dataset): def __init__(self, root_path, win_size, step=1, flag="train"): self.flag = flag self.step = step self.win_size = win_size self.scaler = StandardScaler() data = pd.read_csv(os.path.join(root_path, 'train.csv')) data = data.values[:, 1:] data = np.nan_to_num(data) self.scaler.fit(data) data = self.scaler.transform(data) test_data = pd.read_csv(os.path.join(root_path, 'test.csv')) test_data = test_data.values[:, 1:] test_data = np.nan_to_num(test_data) self.test = self.scaler.transform(test_data) self.train = data self.val = self.test self.test_labels = pd.read_csv(os.path.join(root_path, 'test_label.csv')).values[:, 1:] print("test:", self.test.shape) print("train:", self.train.shape) def __len__(self): if self.flag == "train": return (self.train.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'val'): return (self.val.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'test'): return (self.test.shape[0] - self.win_size) // self.step + 1 else: return (self.test.shape[0] - self.win_size) // self.win_size + 1 def __getitem__(self, index): index = index * self.step if self.flag == "train": return np.float32(self.train[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'val'): return np.float32(self.val[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'test'): return np.float32(self.test[index:index + self.win_size]), np.float32( self.test_labels[index:index + self.win_size]) else: return np.float32(self.test[ index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]), np.float32( self.test_labels[index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]) class MSLSegLoader(Dataset): def __init__(self, root_path, win_size, step=1, flag="train"): self.flag = flag self.step = step self.win_size = win_size self.scaler = StandardScaler() data = np.load(os.path.join(root_path, "MSL_train.npy")) self.scaler.fit(data) data = self.scaler.transform(data) test_data = np.load(os.path.join(root_path, "MSL_test.npy")) self.test = self.scaler.transform(test_data) self.train = data self.val = self.test self.test_labels = np.load(os.path.join(root_path, "MSL_test_label.npy")) print("test:", self.test.shape) print("train:", self.train.shape) def __len__(self): if self.flag == "train": return (self.train.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'val'): return (self.val.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'test'): return (self.test.shape[0] - self.win_size) // self.step + 1 else: return (self.test.shape[0] - self.win_size) // self.win_size + 1 def __getitem__(self, index): index = index * self.step if self.flag == "train": return np.float32(self.train[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'val'): return np.float32(self.val[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'test'): return np.float32(self.test[index:index + self.win_size]), np.float32( self.test_labels[index:index + self.win_size]) else: return np.float32(self.test[ index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]), np.float32( self.test_labels[index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]) class SMAPSegLoader(Dataset): def __init__(self, root_path, win_size, step=1, flag="train"): self.flag = flag self.step = step self.win_size = win_size self.scaler = StandardScaler() data = np.load(os.path.join(root_path, "SMAP_train.npy")) self.scaler.fit(data) data = self.scaler.transform(data) test_data = np.load(os.path.join(root_path, "SMAP_test.npy")) self.test = self.scaler.transform(test_data) self.train = data self.val = self.test self.test_labels = np.load(os.path.join(root_path, "SMAP_test_label.npy")) print("test:", self.test.shape) print("train:", self.train.shape) def __len__(self): if self.flag == "train": return (self.train.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'val'): return (self.val.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'test'): return (self.test.shape[0] - self.win_size) // self.step + 1 else: return (self.test.shape[0] - self.win_size) // self.win_size + 1 def __getitem__(self, index): index = index * self.step if self.flag == "train": return np.float32(self.train[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'val'): return np.float32(self.val[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'test'): return np.float32(self.test[index:index + self.win_size]), np.float32( self.test_labels[index:index + self.win_size]) else: return np.float32(self.test[ index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]), np.float32( self.test_labels[index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]) class SMDSegLoader(Dataset): def __init__(self, root_path, win_size, step=100, flag="train"): self.flag = flag self.step = step self.win_size = win_size self.scaler = StandardScaler() data = np.load(os.path.join(root_path, "SMD_train.npy")) self.scaler.fit(data) data = self.scaler.transform(data) test_data = np.load(os.path.join(root_path, "SMD_test.npy")) self.test = self.scaler.transform(test_data) self.train = data data_len = len(self.train) self.val = self.train[(int)(data_len * 0.8):] self.test_labels = np.load(os.path.join(root_path, "SMD_test_label.npy")) def __len__(self): if self.flag == "train": return (self.train.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'val'): return (self.val.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'test'): return (self.test.shape[0] - self.win_size) // self.step + 1 else: return (self.test.shape[0] - self.win_size) // self.win_size + 1 def __getitem__(self, index): index = index * self.step if self.flag == "train": return np.float32(self.train[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'val'): return np.float32(self.val[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'test'): return np.float32(self.test[index:index + self.win_size]), np.float32( self.test_labels[index:index + self.win_size]) else: return np.float32(self.test[ index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]), np.float32( self.test_labels[index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]) class SWATSegLoader(Dataset): def __init__(self, root_path, win_size, step=1, flag="train"): self.flag = flag self.step = step self.win_size = win_size self.scaler = StandardScaler() train_data = pd.read_csv(os.path.join(root_path, 'swat_train2.csv')) test_data = pd.read_csv(os.path.join(root_path, 'swat2.csv')) labels = test_data.values[:, -1:] train_data = train_data.values[:, :-1] test_data = test_data.values[:, :-1] self.scaler.fit(train_data) train_data = self.scaler.transform(train_data) test_data = self.scaler.transform(test_data) self.train = train_data self.test = test_data self.val = test_data self.test_labels = labels print("test:", self.test.shape) print("train:", self.train.shape) def __len__(self): """ Number of images in the object dataset. """ if self.flag == "train": return (self.train.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'val'): return (self.val.shape[0] - self.win_size) // self.step + 1 elif (self.flag == 'test'): return (self.test.shape[0] - self.win_size) // self.step + 1 else: return (self.test.shape[0] - self.win_size) // self.win_size + 1 def __getitem__(self, index): index = index * self.step if self.flag == "train": return np.float32(self.train[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'val'): return np.float32(self.val[index:index + self.win_size]), np.float32(self.test_labels[0:self.win_size]) elif (self.flag == 'test'): return np.float32(self.test[index:index + self.win_size]), np.float32( self.test_labels[index:index + self.win_size]) else: return np.float32(self.test[ index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]), np.float32( self.test_labels[index // self.step * self.win_size:index // self.step * self.win_size + self.win_size]) class UEAloader(Dataset): """ Dataset class for datasets included in: Time Series Classification Archive (www.timeseriesclassification.com) Argument: limit_size: float in (0, 1) for debug Attributes: all_df: (num_samples * seq_len, num_columns) dataframe indexed by integer indices, with multiple rows corresponding to the same index (sample). Each row is a time step; Each column contains either metadata (e.g. timestamp) or a feature. feature_df: (num_samples * seq_len, feat_dim) dataframe; contains the subset of columns of `all_df` which correspond to selected features feature_names: names of columns contained in `feature_df` (same as feature_df.columns) all_IDs: (num_samples,) series of IDs contained in `all_df`/`feature_df` (same as all_df.index.unique() ) labels_df: (num_samples, num_labels) pd.DataFrame of label(s) for each sample max_seq_len: maximum sequence (time series) length. If None, script argument `max_seq_len` will be used. (Moreover, script argument overrides this attribute) """ def __init__(self, root_path, file_list=None, limit_size=None, flag=None): self.root_path = root_path self.all_df, self.labels_df = self.load_all(root_path, file_list=file_list, flag=flag) self.all_IDs = self.all_df.index.unique() # all sample IDs (integer indices 0 ... num_samples-1) if limit_size is not None: if limit_size > 1: limit_size = int(limit_size) else: # interpret as proportion if in (0, 1] limit_size = int(limit_size * len(self.all_IDs)) self.all_IDs = self.all_IDs[:limit_size] self.all_df = self.all_df.loc[self.all_IDs] # use all features self.feature_names = self.all_df.columns self.feature_df = self.all_df # pre_process normalizer = Normalizer() self.feature_df = normalizer.normalize(self.feature_df) print(len(self.all_IDs)) def load_all(self, root_path, file_list=None, flag=None): """ Loads datasets from csv files contained in `root_path` into a dataframe, optionally choosing from `pattern` Args: root_path: directory containing all individual .csv files file_list: optionally, provide a list of file paths within `root_path` to consider. Otherwise, entire `root_path` contents will be used. Returns: all_df: a single (possibly concatenated) dataframe with all data corresponding to specified files labels_df: dataframe containing label(s) for each sample """ # Select paths for training and evaluation if file_list is None: data_paths = glob.glob(os.path.join(root_path, '*')) # list of all paths else: data_paths = [os.path.join(root_path, p) for p in file_list] if len(data_paths) == 0: raise Exception('No files found using: {}'.format(os.path.join(root_path, '*'))) if flag is not None: data_paths = list(filter(lambda x: re.search(flag, x), data_paths)) input_paths = [p for p in data_paths if os.path.isfile(p) and p.endswith('.ts')] if len(input_paths) == 0: raise Exception("No .ts files found using pattern: '{}'".format(pattern)) all_df, labels_df = self.load_single(input_paths[0]) # a single file contains dataset return all_df, labels_df def load_single(self, filepath): df, labels = load_from_tsfile_to_dataframe(filepath, return_separate_X_and_y=True, replace_missing_vals_with='NaN') labels = pd.Series(labels, dtype="category") self.class_names = labels.cat.categories labels_df = pd.DataFrame(labels.cat.codes, dtype=np.int8) # int8-32 gives an error when using nn.CrossEntropyLoss lengths = df.applymap( lambda x: len(x)).values # (num_samples, num_dimensions) array containing the length of each series horiz_diffs = np.abs(lengths - np.expand_dims(lengths[:, 0], -1)) if np.sum(horiz_diffs) > 0: # if any row (sample) has varying length across dimensions df = df.applymap(subsample) lengths = df.applymap(lambda x: len(x)).values vert_diffs = np.abs(lengths - np.expand_dims(lengths[0, :], 0)) if np.sum(vert_diffs) > 0: # if any column (dimension) has varying length across samples self.max_seq_len = int(np.max(lengths[:, 0])) else: self.max_seq_len = lengths[0, 0] # First create a (seq_len, feat_dim) dataframe for each sample, indexed by a single integer ("ID" of the sample) # Then concatenate into a (num_samples * seq_len, feat_dim) dataframe, with multiple rows corresponding to the # sample index (i.e. the same scheme as all datasets in this project) df = pd.concat((pd.DataFrame({col: df.loc[row, col] for col in df.columns}).reset_index(drop=True).set_index( pd.Series(lengths[row, 0] * [row])) for row in range(df.shape[0])), axis=0) # Replace NaN values grp = df.groupby(by=df.index) df = grp.transform(interpolate_missing) return df, labels_df def instance_norm(self, case): if self.root_path.count('EthanolConcentration') > 0: # special process for numerical stability mean = case.mean(0, keepdim=True) case = case - mean stdev = torch.sqrt(torch.var(case, dim=1, keepdim=True, unbiased=False) + 1e-5) case /= stdev return case else: return case def __getitem__(self, ind): return self.instance_norm(torch.from_numpy(self.feature_df.loc[self.all_IDs[ind]].values)), \ torch.from_numpy(self.labels_df.loc[self.all_IDs[ind]].values) def __len__(self): return len(self.all_IDs) library/data_provider/m4.py000066400000000000000000000105321443355502200162430ustar00rootroot00000000000000# This source code is provided for the purposes of scientific reproducibility # under the following limited license from Element AI Inc. The code is an # implementation of the N-BEATS model (Oreshkin et al., N-BEATS: Neural basis # expansion analysis for interpretable time series forecasting, # https://arxiv.org/abs/1905.10437). The copyright to the source code is # licensed under the Creative Commons - Attribution-NonCommercial 4.0 # International license (CC BY-NC 4.0): # https://creativecommons.org/licenses/by-nc/4.0/. Any commercial use (whether # for the benefit of third parties or internally in production) requires an # explicit license. The subject-matter of the N-BEATS model and associated # materials are the property of Element AI Inc. and may be subject to patent # protection. No license to patents is granted hereunder (whether express or # implied). Copyright © 2020 Element AI Inc. All rights reserved. """ M4 Dataset """ import logging import os from collections import OrderedDict from dataclasses import dataclass from glob import glob import numpy as np import pandas as pd import patoolib from tqdm import tqdm import logging import os import pathlib import sys from urllib import request def url_file_name(url: str) -> str: """ Extract file name from url. :param url: URL to extract file name from. :return: File name. """ return url.split('/')[-1] if len(url) > 0 else '' def download(url: str, file_path: str) -> None: """ Download a file to the given path. :param url: URL to download :param file_path: Where to download the content. """ def progress(count, block_size, total_size): progress_pct = float(count * block_size) / float(total_size) * 100.0 sys.stdout.write('\rDownloading {} to {} {:.1f}%'.format(url, file_path, progress_pct)) sys.stdout.flush() if not os.path.isfile(file_path): opener = request.build_opener() opener.addheaders = [('User-agent', 'Mozilla/5.0')] request.install_opener(opener) pathlib.Path(os.path.dirname(file_path)).mkdir(parents=True, exist_ok=True) f, _ = request.urlretrieve(url, file_path, progress) sys.stdout.write('\n') sys.stdout.flush() file_info = os.stat(f) logging.info(f'Successfully downloaded {os.path.basename(file_path)} {file_info.st_size} bytes.') else: file_info = os.stat(file_path) logging.info(f'File already exists: {file_path} {file_info.st_size} bytes.') @dataclass() class M4Dataset: ids: np.ndarray groups: np.ndarray frequencies: np.ndarray horizons: np.ndarray values: np.ndarray @staticmethod def load(training: bool = True, dataset_file: str = '../dataset/m4') -> 'M4Dataset': """ Load cached dataset. :param training: Load training part if training is True, test part otherwise. """ info_file = os.path.join(dataset_file, 'M4-info.csv') train_cache_file = os.path.join(dataset_file, 'training.npz') test_cache_file = os.path.join(dataset_file, 'test.npz') m4_info = pd.read_csv(info_file) return M4Dataset(ids=m4_info.M4id.values, groups=m4_info.SP.values, frequencies=m4_info.Frequency.values, horizons=m4_info.Horizon.values, values=np.load( train_cache_file if training else test_cache_file, allow_pickle=True)) @dataclass() class M4Meta: seasonal_patterns = ['Yearly', 'Quarterly', 'Monthly', 'Weekly', 'Daily', 'Hourly'] horizons = [6, 8, 18, 13, 14, 48] frequencies = [1, 4, 12, 1, 1, 24] horizons_map = { 'Yearly': 6, 'Quarterly': 8, 'Monthly': 18, 'Weekly': 13, 'Daily': 14, 'Hourly': 48 } # different predict length frequency_map = { 'Yearly': 1, 'Quarterly': 4, 'Monthly': 12, 'Weekly': 1, 'Daily': 1, 'Hourly': 24 } history_size = { 'Yearly': 1.5, 'Quarterly': 1.5, 'Monthly': 1.5, 'Weekly': 10, 'Daily': 10, 'Hourly': 10 } # from interpretable.gin def load_m4_info() -> pd.DataFrame: """ Load M4Info file. :return: Pandas DataFrame of M4Info. """ return pd.read_csv(INFO_FILE_PATH) library/data_provider/uea.py000066400000000000000000000116541443355502200165030ustar00rootroot00000000000000import os import numpy as np import pandas as pd import torch def collate_fn(data, max_len=None): """Build mini-batch tensors from a list of (X, mask) tuples. Mask input. Create Args: data: len(batch_size) list of tuples (X, y). - X: torch tensor of shape (seq_length, feat_dim); variable seq_length. - y: torch tensor of shape (num_labels,) : class indices or numerical targets (for classification or regression, respectively). num_labels > 1 for multi-task models max_len: global fixed sequence length. Used for architectures requiring fixed length input, where the batch length cannot vary dynamically. Longer sequences are clipped, shorter are padded with 0s Returns: X: (batch_size, padded_length, feat_dim) torch tensor of masked features (input) targets: (batch_size, padded_length, feat_dim) torch tensor of unmasked features (output) target_masks: (batch_size, padded_length, feat_dim) boolean torch tensor 0 indicates masked values to be predicted, 1 indicates unaffected/"active" feature values padding_masks: (batch_size, padded_length) boolean tensor, 1 means keep vector at this position, 0 means padding """ batch_size = len(data) features, labels = zip(*data) # Stack and pad features and masks (convert 2D to 3D tensors, i.e. add batch dimension) lengths = [X.shape[0] for X in features] # original sequence length for each time series if max_len is None: max_len = max(lengths) X = torch.zeros(batch_size, max_len, features[0].shape[-1]) # (batch_size, padded_length, feat_dim) for i in range(batch_size): end = min(lengths[i], max_len) X[i, :end, :] = features[i][:end, :] targets = torch.stack(labels, dim=0) # (batch_size, num_labels) padding_masks = padding_mask(torch.tensor(lengths, dtype=torch.int16), max_len=max_len) # (batch_size, padded_length) boolean tensor, "1" means keep return X, targets, padding_masks def padding_mask(lengths, max_len=None): """ Used to mask padded positions: creates a (batch_size, max_len) boolean mask from a tensor of sequence lengths, where 1 means keep element at this position (time step) """ batch_size = lengths.numel() max_len = max_len or lengths.max_val() # trick works because of overloading of 'or' operator for non-boolean types return (torch.arange(0, max_len, device=lengths.device) .type_as(lengths) .repeat(batch_size, 1) .lt(lengths.unsqueeze(1))) class Normalizer(object): """ Normalizes dataframe across ALL contained rows (time steps). Different from per-sample normalization. """ def __init__(self, norm_type='standardization', mean=None, std=None, min_val=None, max_val=None): """ Args: norm_type: choose from: "standardization", "minmax": normalizes dataframe across ALL contained rows (time steps) "per_sample_std", "per_sample_minmax": normalizes each sample separately (i.e. across only its own rows) mean, std, min_val, max_val: optional (num_feat,) Series of pre-computed values """ self.norm_type = norm_type self.mean = mean self.std = std self.min_val = min_val self.max_val = max_val def normalize(self, df): """ Args: df: input dataframe Returns: df: normalized dataframe """ if self.norm_type == "standardization": if self.mean is None: self.mean = df.mean() self.std = df.std() return (df - self.mean) / (self.std + np.finfo(float).eps) elif self.norm_type == "minmax": if self.max_val is None: self.max_val = df.max() self.min_val = df.min() return (df - self.min_val) / (self.max_val - self.min_val + np.finfo(float).eps) elif self.norm_type == "per_sample_std": grouped = df.groupby(by=df.index) return (df - grouped.transform('mean')) / grouped.transform('std') elif self.norm_type == "per_sample_minmax": grouped = df.groupby(by=df.index) min_vals = grouped.transform('min') return (df - min_vals) / (grouped.transform('max') - min_vals + np.finfo(float).eps) else: raise (NameError(f'Normalize method "{self.norm_type}" not implemented')) def interpolate_missing(y): """ Replaces NaN values in pd.Series `y` using linear interpolation """ if y.isna().any(): y = y.interpolate(method='linear', limit_direction='both') return y def subsample(y, limit=256, factor=2): """ If a given Series is longer than `limit`, returns subsampled sequence by the specified integer factor """ if len(y) > limit: return y[::factor].reset_index(drop=True) return y library/exp/000077500000000000000000000000001443355502200133215ustar00rootroot00000000000000library/exp/__init__.py000066400000000000000000000000001443355502200154200ustar00rootroot00000000000000library/exp/exp_anomaly_detection.py000066400000000000000000000172101443355502200202460ustar00rootroot00000000000000from data_provider.data_factory import data_provider from exp.exp_basic import Exp_Basic from utils.tools import EarlyStopping, adjust_learning_rate, adjustment from sklearn.metrics import precision_recall_fscore_support from sklearn.metrics import accuracy_score import torch.multiprocessing torch.multiprocessing.set_sharing_strategy('file_system') import torch import torch.nn as nn from torch import optim import os import time import warnings import numpy as np warnings.filterwarnings('ignore') class Exp_Anomaly_Detection(Exp_Basic): def __init__(self, args): super(Exp_Anomaly_Detection, self).__init__(args) def _build_model(self): model = self.model_dict[self.args.model].Model(self.args).float() if self.args.use_multi_gpu and self.args.use_gpu: model = nn.DataParallel(model, device_ids=self.args.device_ids) return model def _get_data(self, flag): data_set, data_loader = data_provider(self.args, flag) return data_set, data_loader def _select_optimizer(self): model_optim = optim.Adam(self.model.parameters(), lr=self.args.learning_rate) return model_optim def _select_criterion(self): criterion = nn.MSELoss() return criterion def vali(self, vali_data, vali_loader, criterion): total_loss = [] self.model.eval() with torch.no_grad(): for i, (batch_x, _) in enumerate(vali_loader): batch_x = batch_x.float().to(self.device) outputs = self.model(batch_x, None, None, None) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, :, f_dim:] pred = outputs.detach().cpu() true = batch_x.detach().cpu() loss = criterion(pred, true) total_loss.append(loss) total_loss = np.average(total_loss) self.model.train() return total_loss def train(self, setting): train_data, train_loader = self._get_data(flag='train') vali_data, vali_loader = self._get_data(flag='val') test_data, test_loader = self._get_data(flag='test') path = os.path.join(self.args.checkpoints, setting) if not os.path.exists(path): os.makedirs(path) time_now = time.time() train_steps = len(train_loader) early_stopping = EarlyStopping(patience=self.args.patience, verbose=True) model_optim = self._select_optimizer() criterion = self._select_criterion() for epoch in range(self.args.train_epochs): iter_count = 0 train_loss = [] self.model.train() epoch_time = time.time() for i, (batch_x, batch_y) in enumerate(train_loader): iter_count += 1 model_optim.zero_grad() batch_x = batch_x.float().to(self.device) outputs = self.model(batch_x, None, None, None) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, :, f_dim:] loss = criterion(outputs, batch_x) train_loss.append(loss.item()) if (i + 1) % 100 == 0: print("\titers: {0}, epoch: {1} | loss: {2:.7f}".format(i + 1, epoch + 1, loss.item())) speed = (time.time() - time_now) / iter_count left_time = speed * ((self.args.train_epochs - epoch) * train_steps - i) print('\tspeed: {:.4f}s/iter; left time: {:.4f}s'.format(speed, left_time)) iter_count = 0 time_now = time.time() loss.backward() model_optim.step() print("Epoch: {} cost time: {}".format(epoch + 1, time.time() - epoch_time)) train_loss = np.average(train_loss) vali_loss = self.vali(vali_data, vali_loader, criterion) test_loss = self.vali(test_data, test_loader, criterion) print("Epoch: {0}, Steps: {1} | Train Loss: {2:.7f} Vali Loss: {3:.7f} Test Loss: {4:.7f}".format( epoch + 1, train_steps, train_loss, vali_loss, test_loss)) early_stopping(vali_loss, self.model, path) if early_stopping.early_stop: print("Early stopping") break adjust_learning_rate(model_optim, epoch + 1, self.args) best_model_path = path + '/' + 'checkpoint.pth' self.model.load_state_dict(torch.load(best_model_path)) return self.model def test(self, setting, test=0): test_data, test_loader = self._get_data(flag='test') train_data, train_loader = self._get_data(flag='train') if test: print('loading model') self.model.load_state_dict(torch.load(os.path.join('./checkpoints/' + setting, 'checkpoint.pth'))) attens_energy = [] folder_path = './test_results/' + setting + '/' if not os.path.exists(folder_path): os.makedirs(folder_path) self.model.eval() self.anomaly_criterion = nn.MSELoss(reduce=False) # (1) stastic on the train set with torch.no_grad(): for i, (batch_x, batch_y) in enumerate(train_loader): batch_x = batch_x.float().to(self.device) # reconstruction outputs = self.model(batch_x, None, None, None) # criterion score = torch.mean(self.anomaly_criterion(batch_x, outputs), dim=-1) score = score.detach().cpu().numpy() attens_energy.append(score) attens_energy = np.concatenate(attens_energy, axis=0).reshape(-1) train_energy = np.array(attens_energy) # (2) find the threshold attens_energy = [] test_labels = [] for i, (batch_x, batch_y) in enumerate(test_loader): batch_x = batch_x.float().to(self.device) # reconstruction outputs = self.model(batch_x, None, None, None) # criterion score = torch.mean(self.anomaly_criterion(batch_x, outputs), dim=-1) score = score.detach().cpu().numpy() attens_energy.append(score) test_labels.append(batch_y) attens_energy = np.concatenate(attens_energy, axis=0).reshape(-1) test_energy = np.array(attens_energy) combined_energy = np.concatenate([train_energy, test_energy], axis=0) threshold = np.percentile(combined_energy, 100 - self.args.anomaly_ratio) print("Threshold :", threshold) # (3) evaluation on the test set pred = (test_energy > threshold).astype(int) test_labels = np.concatenate(test_labels, axis=0).reshape(-1) test_labels = np.array(test_labels) gt = test_labels.astype(int) print("pred: ", pred.shape) print("gt: ", gt.shape) # (4) detection adjustment gt, pred = adjustment(gt, pred) pred = np.array(pred) gt = np.array(gt) print("pred: ", pred.shape) print("gt: ", gt.shape) accuracy = accuracy_score(gt, pred) precision, recall, f_score, support = precision_recall_fscore_support(gt, pred, average='binary') print("Accuracy : {:0.4f}, Precision : {:0.4f}, Recall : {:0.4f}, F-score : {:0.4f} ".format( accuracy, precision, recall, f_score)) f = open("result_anomaly_detection.txt", 'a') f.write(setting + " \n") f.write("Accuracy : {:0.4f}, Precision : {:0.4f}, Recall : {:0.4f}, F-score : {:0.4f} ".format( accuracy, precision, recall, f_score)) f.write('\n') f.write('\n') f.close() return library/exp/exp_basic.py000066400000000000000000000031551443355502200156340ustar00rootroot00000000000000import os import torch from models import Autoformer, Transformer, TimesNet, Nonstationary_Transformer, DLinear, FEDformer, \ Informer, LightTS, Reformer, ETSformer, Pyraformer, PatchTST, MICN, Crossformer, FiLM class Exp_Basic(object): def __init__(self, args): self.args = args self.model_dict = { 'TimesNet': TimesNet, 'Autoformer': Autoformer, 'Transformer': Transformer, 'Nonstationary_Transformer': Nonstationary_Transformer, 'DLinear': DLinear, 'FEDformer': FEDformer, 'Informer': Informer, 'LightTS': LightTS, 'Reformer': Reformer, 'ETSformer': ETSformer, 'PatchTST': PatchTST, 'Pyraformer': Pyraformer, 'MICN': MICN, 'Crossformer': Crossformer, 'FiLM': FiLM, } self.device = self._acquire_device() self.model = self._build_model().to(self.device) def _build_model(self): raise NotImplementedError return None def _acquire_device(self): if self.args.use_gpu: os.environ["CUDA_VISIBLE_DEVICES"] = str( self.args.gpu) if not self.args.use_multi_gpu else self.args.devices device = torch.device('cuda:{}'.format(self.args.gpu)) print('Use GPU: cuda:{}'.format(self.args.gpu)) else: device = torch.device('cpu') print('Use CPU') return device def _get_data(self): pass def vali(self): pass def train(self): pass def test(self): pass library/exp/exp_classification.py000066400000000000000000000164051443355502200175500ustar00rootroot00000000000000from data_provider.data_factory import data_provider from exp.exp_basic import Exp_Basic from utils.tools import EarlyStopping, adjust_learning_rate, cal_accuracy import torch import torch.nn as nn from torch import optim import os import time import warnings import numpy as np import pdb warnings.filterwarnings('ignore') class Exp_Classification(Exp_Basic): def __init__(self, args): super(Exp_Classification, self).__init__(args) def _build_model(self): # model input depends on data train_data, train_loader = self._get_data(flag='TRAIN') test_data, test_loader = self._get_data(flag='TEST') self.args.seq_len = max(train_data.max_seq_len, test_data.max_seq_len) self.args.pred_len = 0 self.args.enc_in = train_data.feature_df.shape[1] self.args.num_class = len(train_data.class_names) # model init model = self.model_dict[self.args.model].Model(self.args).float() if self.args.use_multi_gpu and self.args.use_gpu: model = nn.DataParallel(model, device_ids=self.args.device_ids) return model def _get_data(self, flag): data_set, data_loader = data_provider(self.args, flag) return data_set, data_loader def _select_optimizer(self): model_optim = optim.Adam(self.model.parameters(), lr=self.args.learning_rate) return model_optim def _select_criterion(self): criterion = nn.CrossEntropyLoss() return criterion def vali(self, vali_data, vali_loader, criterion): total_loss = [] preds = [] trues = [] self.model.eval() with torch.no_grad(): for i, (batch_x, label, padding_mask) in enumerate(vali_loader): batch_x = batch_x.float().to(self.device) padding_mask = padding_mask.float().to(self.device) label = label.to(self.device) outputs = self.model(batch_x, padding_mask, None, None) pred = outputs.detach().cpu() loss = criterion(pred, label.long().squeeze().cpu()) total_loss.append(loss) preds.append(outputs.detach()) trues.append(label) total_loss = np.average(total_loss) preds = torch.cat(preds, 0) trues = torch.cat(trues, 0) probs = torch.nn.functional.softmax(preds) # (total_samples, num_classes) est. prob. for each class and sample predictions = torch.argmax(probs, dim=1).cpu().numpy() # (total_samples,) int class index for each sample trues = trues.flatten().cpu().numpy() accuracy = cal_accuracy(predictions, trues) self.model.train() return total_loss, accuracy def train(self, setting): train_data, train_loader = self._get_data(flag='TRAIN') vali_data, vali_loader = self._get_data(flag='TEST') test_data, test_loader = self._get_data(flag='TEST') path = os.path.join(self.args.checkpoints, setting) if not os.path.exists(path): os.makedirs(path) time_now = time.time() train_steps = len(train_loader) early_stopping = EarlyStopping(patience=self.args.patience, verbose=True) model_optim = self._select_optimizer() criterion = self._select_criterion() for epoch in range(self.args.train_epochs): iter_count = 0 train_loss = [] self.model.train() epoch_time = time.time() for i, (batch_x, label, padding_mask) in enumerate(train_loader): iter_count += 1 model_optim.zero_grad() batch_x = batch_x.float().to(self.device) padding_mask = padding_mask.float().to(self.device) label = label.to(self.device) outputs = self.model(batch_x, padding_mask, None, None) loss = criterion(outputs, label.long().squeeze(-1)) train_loss.append(loss.item()) if (i + 1) % 100 == 0: print("\titers: {0}, epoch: {1} | loss: {2:.7f}".format(i + 1, epoch + 1, loss.item())) speed = (time.time() - time_now) / iter_count left_time = speed * ((self.args.train_epochs - epoch) * train_steps - i) print('\tspeed: {:.4f}s/iter; left time: {:.4f}s'.format(speed, left_time)) iter_count = 0 time_now = time.time() loss.backward() nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=4.0) model_optim.step() print("Epoch: {} cost time: {}".format(epoch + 1, time.time() - epoch_time)) train_loss = np.average(train_loss) vali_loss, val_accuracy = self.vali(vali_data, vali_loader, criterion) test_loss, test_accuracy = self.vali(test_data, test_loader, criterion) print( "Epoch: {0}, Steps: {1} | Train Loss: {2:.3f} Vali Loss: {3:.3f} Vali Acc: {4:.3f} Test Loss: {5:.3f} Test Acc: {6:.3f}" .format(epoch + 1, train_steps, train_loss, vali_loss, val_accuracy, test_loss, test_accuracy)) early_stopping(-val_accuracy, self.model, path) if early_stopping.early_stop: print("Early stopping") break if (epoch + 1) % 5 == 0: adjust_learning_rate(model_optim, epoch + 1, self.args) best_model_path = path + '/' + 'checkpoint.pth' self.model.load_state_dict(torch.load(best_model_path)) return self.model def test(self, setting, test=0): test_data, test_loader = self._get_data(flag='TEST') if test: print('loading model') self.model.load_state_dict(torch.load(os.path.join('./checkpoints/' + setting, 'checkpoint.pth'))) preds = [] trues = [] folder_path = './test_results/' + setting + '/' if not os.path.exists(folder_path): os.makedirs(folder_path) self.model.eval() with torch.no_grad(): for i, (batch_x, label, padding_mask) in enumerate(test_loader): batch_x = batch_x.float().to(self.device) padding_mask = padding_mask.float().to(self.device) label = label.to(self.device) outputs = self.model(batch_x, padding_mask, None, None) preds.append(outputs.detach()) trues.append(label) preds = torch.cat(preds, 0) trues = torch.cat(trues, 0) print('test shape:', preds.shape, trues.shape) probs = torch.nn.functional.softmax(preds) # (total_samples, num_classes) est. prob. for each class and sample predictions = torch.argmax(probs, dim=1).cpu().numpy() # (total_samples,) int class index for each sample trues = trues.flatten().cpu().numpy() accuracy = cal_accuracy(predictions, trues) # result save folder_path = './results/' + setting + '/' if not os.path.exists(folder_path): os.makedirs(folder_path) print('accuracy:{}'.format(accuracy)) f = open("result_classification.txt", 'a') f.write(setting + " \n") f.write('accuracy:{}'.format(accuracy)) f.write('\n') f.write('\n') f.close() return library/exp/exp_imputation.py000066400000000000000000000201041443355502200167350ustar00rootroot00000000000000from data_provider.data_factory import data_provider from exp.exp_basic import Exp_Basic from utils.tools import EarlyStopping, adjust_learning_rate, visual from utils.metrics import metric import torch import torch.nn as nn from torch import optim import os import time import warnings import numpy as np warnings.filterwarnings('ignore') class Exp_Imputation(Exp_Basic): def __init__(self, args): super(Exp_Imputation, self).__init__(args) def _build_model(self): model = self.model_dict[self.args.model].Model(self.args).float() if self.args.use_multi_gpu and self.args.use_gpu: model = nn.DataParallel(model, device_ids=self.args.device_ids) return model def _get_data(self, flag): data_set, data_loader = data_provider(self.args, flag) return data_set, data_loader def _select_optimizer(self): model_optim = optim.Adam(self.model.parameters(), lr=self.args.learning_rate) return model_optim def _select_criterion(self): criterion = nn.MSELoss() return criterion def vali(self, vali_data, vali_loader, criterion): total_loss = [] self.model.eval() with torch.no_grad(): for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(vali_loader): batch_x = batch_x.float().to(self.device) batch_x_mark = batch_x_mark.float().to(self.device) # random mask B, T, N = batch_x.shape """ B = batch size T = seq len N = number of features """ mask = torch.rand((B, T, N)).to(self.device) mask[mask <= self.args.mask_rate] = 0 # masked mask[mask > self.args.mask_rate] = 1 # remained inp = batch_x.masked_fill(mask == 0, 0) outputs = self.model(inp, batch_x_mark, None, None, mask) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, :, f_dim:] pred = outputs.detach().cpu() true = batch_x.detach().cpu() mask = mask.detach().cpu() loss = criterion(pred[mask == 0], true[mask == 0]) total_loss.append(loss) total_loss = np.average(total_loss) self.model.train() return total_loss def train(self, setting): train_data, train_loader = self._get_data(flag='train') vali_data, vali_loader = self._get_data(flag='val') test_data, test_loader = self._get_data(flag='test') path = os.path.join(self.args.checkpoints, setting) if not os.path.exists(path): os.makedirs(path) time_now = time.time() train_steps = len(train_loader) early_stopping = EarlyStopping(patience=self.args.patience, verbose=True) model_optim = self._select_optimizer() criterion = self._select_criterion() for epoch in range(self.args.train_epochs): iter_count = 0 train_loss = [] self.model.train() epoch_time = time.time() for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(train_loader): iter_count += 1 model_optim.zero_grad() batch_x = batch_x.float().to(self.device) batch_x_mark = batch_x_mark.float().to(self.device) # random mask B, T, N = batch_x.shape mask = torch.rand((B, T, N)).to(self.device) mask[mask <= self.args.mask_rate] = 0 # masked mask[mask > self.args.mask_rate] = 1 # remained inp = batch_x.masked_fill(mask == 0, 0) outputs = self.model(inp, batch_x_mark, None, None, mask) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, :, f_dim:] loss = criterion(outputs[mask == 0], batch_x[mask == 0]) train_loss.append(loss.item()) if (i + 1) % 100 == 0: print("\titers: {0}, epoch: {1} | loss: {2:.7f}".format(i + 1, epoch + 1, loss.item())) speed = (time.time() - time_now) / iter_count left_time = speed * ((self.args.train_epochs - epoch) * train_steps - i) print('\tspeed: {:.4f}s/iter; left time: {:.4f}s'.format(speed, left_time)) iter_count = 0 time_now = time.time() loss.backward() model_optim.step() print("Epoch: {} cost time: {}".format(epoch + 1, time.time() - epoch_time)) train_loss = np.average(train_loss) vali_loss = self.vali(vali_data, vali_loader, criterion) test_loss = self.vali(test_data, test_loader, criterion) print("Epoch: {0}, Steps: {1} | Train Loss: {2:.7f} Vali Loss: {3:.7f} Test Loss: {4:.7f}".format( epoch + 1, train_steps, train_loss, vali_loss, test_loss)) early_stopping(vali_loss, self.model, path) if early_stopping.early_stop: print("Early stopping") break adjust_learning_rate(model_optim, epoch + 1, self.args) best_model_path = path + '/' + 'checkpoint.pth' self.model.load_state_dict(torch.load(best_model_path)) return self.model def test(self, setting, test=0): test_data, test_loader = self._get_data(flag='test') if test: print('loading model') self.model.load_state_dict(torch.load(os.path.join('./checkpoints/' + setting, 'checkpoint.pth'))) preds = [] trues = [] masks = [] folder_path = './test_results/' + setting + '/' if not os.path.exists(folder_path): os.makedirs(folder_path) self.model.eval() with torch.no_grad(): for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(test_loader): batch_x = batch_x.float().to(self.device) batch_x_mark = batch_x_mark.float().to(self.device) # random mask B, T, N = batch_x.shape mask = torch.rand((B, T, N)).to(self.device) mask[mask <= self.args.mask_rate] = 0 # masked mask[mask > self.args.mask_rate] = 1 # remained inp = batch_x.masked_fill(mask == 0, 0) # imputation outputs = self.model(inp, batch_x_mark, None, None, mask) # eval f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, :, f_dim:] outputs = outputs.detach().cpu().numpy() pred = outputs true = batch_x.detach().cpu().numpy() preds.append(pred) trues.append(true) masks.append(mask.detach().cpu()) if i % 20 == 0: filled = true[0, :, -1].copy() filled = filled * mask[0, :, -1].detach().cpu().numpy() + \ pred[0, :, -1] * (1 - mask[0, :, -1].detach().cpu().numpy()) visual(true[0, :, -1], filled, os.path.join(folder_path, str(i) + '.pdf')) preds = np.concatenate(preds, 0) trues = np.concatenate(trues, 0) masks = np.concatenate(masks, 0) print('test shape:', preds.shape, trues.shape) # result save folder_path = './results/' + setting + '/' if not os.path.exists(folder_path): os.makedirs(folder_path) mae, mse, rmse, mape, mspe = metric(preds[masks == 0], trues[masks == 0]) print('mse:{}, mae:{}'.format(mse, mae)) f = open("result_imputation.txt", 'a') f.write(setting + " \n") f.write('mse:{}, mae:{}'.format(mse, mae)) f.write('\n') f.write('\n') f.close() np.save(folder_path + 'metrics.npy', np.array([mae, mse, rmse, mape, mspe])) np.save(folder_path + 'pred.npy', preds) np.save(folder_path + 'true.npy', trues) return library/exp/exp_long_term_forecasting.py000066400000000000000000000253601443355502200211270ustar00rootroot00000000000000from data_provider.data_factory import data_provider from exp.exp_basic import Exp_Basic from utils.tools import EarlyStopping, adjust_learning_rate, visual from utils.metrics import metric import torch import torch.nn as nn from torch import optim import os import time import warnings import numpy as np warnings.filterwarnings('ignore') class Exp_Long_Term_Forecast(Exp_Basic): def __init__(self, args): super(Exp_Long_Term_Forecast, self).__init__(args) def _build_model(self): model = self.model_dict[self.args.model].Model(self.args).float() if self.args.use_multi_gpu and self.args.use_gpu: model = nn.DataParallel(model, device_ids=self.args.device_ids) return model def _get_data(self, flag): data_set, data_loader = data_provider(self.args, flag) return data_set, data_loader def _select_optimizer(self): model_optim = optim.Adam(self.model.parameters(), lr=self.args.learning_rate) return model_optim def _select_criterion(self): criterion = nn.MSELoss() return criterion def vali(self, vali_data, vali_loader, criterion): total_loss = [] self.model.eval() with torch.no_grad(): for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(vali_loader): batch_x = batch_x.float().to(self.device) batch_y = batch_y.float() batch_x_mark = batch_x_mark.float().to(self.device) batch_y_mark = batch_y_mark.float().to(self.device) # decoder input dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float() dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device) # encoder - decoder if self.args.use_amp: with torch.cuda.amp.autocast(): if self.args.output_attention: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] else: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) else: if self.args.output_attention: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] else: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, -self.args.pred_len:, f_dim:] batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device) pred = outputs.detach().cpu() true = batch_y.detach().cpu() loss = criterion(pred, true) total_loss.append(loss) total_loss = np.average(total_loss) self.model.train() return total_loss def train(self, setting): train_data, train_loader = self._get_data(flag='train') vali_data, vali_loader = self._get_data(flag='val') test_data, test_loader = self._get_data(flag='test') path = os.path.join(self.args.checkpoints, setting) if not os.path.exists(path): os.makedirs(path) time_now = time.time() train_steps = len(train_loader) early_stopping = EarlyStopping(patience=self.args.patience, verbose=True) model_optim = self._select_optimizer() criterion = self._select_criterion() if self.args.use_amp: scaler = torch.cuda.amp.GradScaler() for epoch in range(self.args.train_epochs): iter_count = 0 train_loss = [] self.model.train() epoch_time = time.time() for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(train_loader): iter_count += 1 model_optim.zero_grad() batch_x = batch_x.float().to(self.device) batch_y = batch_y.float().to(self.device) batch_x_mark = batch_x_mark.float().to(self.device) batch_y_mark = batch_y_mark.float().to(self.device) # decoder input dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float() dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device) # encoder - decoder if self.args.use_amp: with torch.cuda.amp.autocast(): if self.args.output_attention: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] else: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, -self.args.pred_len:, f_dim:] batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device) loss = criterion(outputs, batch_y) train_loss.append(loss.item()) else: if self.args.output_attention: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] else: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, -self.args.pred_len:, f_dim:] batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device) loss = criterion(outputs, batch_y) train_loss.append(loss.item()) if (i + 1) % 100 == 0: print("\titers: {0}, epoch: {1} | loss: {2:.7f}".format(i + 1, epoch + 1, loss.item())) speed = (time.time() - time_now) / iter_count left_time = speed * ((self.args.train_epochs - epoch) * train_steps - i) print('\tspeed: {:.4f}s/iter; left time: {:.4f}s'.format(speed, left_time)) iter_count = 0 time_now = time.time() if self.args.use_amp: scaler.scale(loss).backward() scaler.step(model_optim) scaler.update() else: loss.backward() model_optim.step() print("Epoch: {} cost time: {}".format(epoch + 1, time.time() - epoch_time)) train_loss = np.average(train_loss) vali_loss = self.vali(vali_data, vali_loader, criterion) test_loss = self.vali(test_data, test_loader, criterion) print("Epoch: {0}, Steps: {1} | Train Loss: {2:.7f} Vali Loss: {3:.7f} Test Loss: {4:.7f}".format( epoch + 1, train_steps, train_loss, vali_loss, test_loss)) early_stopping(vali_loss, self.model, path) if early_stopping.early_stop: print("Early stopping") break adjust_learning_rate(model_optim, epoch + 1, self.args) best_model_path = path + '/' + 'checkpoint.pth' self.model.load_state_dict(torch.load(best_model_path)) return self.model def test(self, setting, test=0): test_data, test_loader = self._get_data(flag='test') if test: print('loading model') self.model.load_state_dict(torch.load(os.path.join('./checkpoints/' + setting, 'checkpoint.pth'))) preds = [] trues = [] folder_path = './test_results/' + setting + '/' if not os.path.exists(folder_path): os.makedirs(folder_path) self.model.eval() with torch.no_grad(): for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(test_loader): batch_x = batch_x.float().to(self.device) batch_y = batch_y.float().to(self.device) batch_x_mark = batch_x_mark.float().to(self.device) batch_y_mark = batch_y_mark.float().to(self.device) # decoder input dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float() dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device) # encoder - decoder if self.args.use_amp: with torch.cuda.amp.autocast(): if self.args.output_attention: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] else: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) else: if self.args.output_attention: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0] else: outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, -self.args.pred_len:, f_dim:] batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device) outputs = outputs.detach().cpu().numpy() batch_y = batch_y.detach().cpu().numpy() pred = outputs true = batch_y preds.append(pred) trues.append(true) if i % 20 == 0: input = batch_x.detach().cpu().numpy() gt = np.concatenate((input[0, :, -1], true[0, :, -1]), axis=0) pd = np.concatenate((input[0, :, -1], pred[0, :, -1]), axis=0) visual(gt, pd, os.path.join(folder_path, str(i) + '.pdf')) preds = np.array(preds) trues = np.array(trues) print('test shape:', preds.shape, trues.shape) preds = preds.reshape(-1, preds.shape[-2], preds.shape[-1]) trues = trues.reshape(-1, trues.shape[-2], trues.shape[-1]) print('test shape:', preds.shape, trues.shape) # result save folder_path = './results/' + setting + '/' if not os.path.exists(folder_path): os.makedirs(folder_path) mae, mse, rmse, mape, mspe = metric(preds, trues) print('mse:{}, mae:{}'.format(mse, mae)) f = open("result_long_term_forecast.txt", 'a') f.write(setting + " \n") f.write('mse:{}, mae:{}'.format(mse, mae)) f.write('\n') f.write('\n') f.close() np.save(folder_path + 'metrics.npy', np.array([mae, mse, rmse, mape, mspe])) np.save(folder_path + 'pred.npy', preds) np.save(folder_path + 'true.npy', trues) return library/exp/exp_short_term_forecasting.py000066400000000000000000000241331443355502200213240ustar00rootroot00000000000000from data_provider.data_factory import data_provider from data_provider.m4 import M4Meta from exp.exp_basic import Exp_Basic from utils.tools import EarlyStopping, adjust_learning_rate, visual from utils.losses import mape_loss, mase_loss, smape_loss from utils.m4_summary import M4Summary import torch import torch.nn as nn from torch import optim import os import time import warnings import numpy as np import pandas warnings.filterwarnings('ignore') class Exp_Short_Term_Forecast(Exp_Basic): def __init__(self, args): super(Exp_Short_Term_Forecast, self).__init__(args) def _build_model(self): if self.args.data == 'm4': self.args.pred_len = M4Meta.horizons_map[self.args.seasonal_patterns] # Up to M4 config self.args.seq_len = 2 * self.args.pred_len # input_len = 2*pred_len self.args.label_len = self.args.pred_len self.args.frequency_map = M4Meta.frequency_map[self.args.seasonal_patterns] model = self.model_dict[self.args.model].Model(self.args).float() if self.args.use_multi_gpu and self.args.use_gpu: model = nn.DataParallel(model, device_ids=self.args.device_ids) return model def _get_data(self, flag): data_set, data_loader = data_provider(self.args, flag) return data_set, data_loader def _select_optimizer(self): model_optim = optim.Adam(self.model.parameters(), lr=self.args.learning_rate) return model_optim def _select_criterion(self, loss_name='MSE'): if loss_name == 'MSE': return nn.MSELoss() elif loss_name == 'MAPE': return mape_loss() elif loss_name == 'MASE': return mase_loss() elif loss_name == 'SMAPE': return smape_loss() def train(self, setting): train_data, train_loader = self._get_data(flag='train') vali_data, vali_loader = self._get_data(flag='val') path = os.path.join(self.args.checkpoints, setting) if not os.path.exists(path): os.makedirs(path) time_now = time.time() train_steps = len(train_loader) early_stopping = EarlyStopping(patience=self.args.patience, verbose=True) model_optim = self._select_optimizer() criterion = self._select_criterion(self.args.loss) mse = nn.MSELoss() for epoch in range(self.args.train_epochs): iter_count = 0 train_loss = [] self.model.train() epoch_time = time.time() for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(train_loader): iter_count += 1 model_optim.zero_grad() batch_x = batch_x.float().to(self.device) batch_y = batch_y.float().to(self.device) batch_y_mark = batch_y_mark.float().to(self.device) # decoder input dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float() dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device) outputs = self.model(batch_x, None, dec_inp, None) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, -self.args.pred_len:, f_dim:] batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device) batch_y_mark = batch_y_mark[:, -self.args.pred_len:, f_dim:].to(self.device) loss_value = criterion(batch_x, self.args.frequency_map, outputs, batch_y, batch_y_mark) loss_sharpness = mse((outputs[:, 1:, :] - outputs[:, :-1, :]), (batch_y[:, 1:, :] - batch_y[:, :-1, :])) loss = loss_value # + loss_sharpness * 1e-5 train_loss.append(loss.item()) if (i + 1) % 100 == 0: print("\titers: {0}, epoch: {1} | loss: {2:.7f}".format(i + 1, epoch + 1, loss.item())) speed = (time.time() - time_now) / iter_count left_time = speed * ((self.args.train_epochs - epoch) * train_steps - i) print('\tspeed: {:.4f}s/iter; left time: {:.4f}s'.format(speed, left_time)) iter_count = 0 time_now = time.time() loss.backward() model_optim.step() print("Epoch: {} cost time: {}".format(epoch + 1, time.time() - epoch_time)) train_loss = np.average(train_loss) vali_loss = self.vali(train_loader, vali_loader, criterion) test_loss = vali_loss print("Epoch: {0}, Steps: {1} | Train Loss: {2:.7f} Vali Loss: {3:.7f} Test Loss: {4:.7f}".format( epoch + 1, train_steps, train_loss, vali_loss, test_loss)) early_stopping(vali_loss, self.model, path) if early_stopping.early_stop: print("Early stopping") break adjust_learning_rate(model_optim, epoch + 1, self.args) best_model_path = path + '/' + 'checkpoint.pth' self.model.load_state_dict(torch.load(best_model_path)) return self.model def vali(self, train_loader, vali_loader, criterion): x, _ = train_loader.dataset.last_insample_window() y = vali_loader.dataset.timeseries x = torch.tensor(x, dtype=torch.float32).to(self.device) x = x.unsqueeze(-1) self.model.eval() with torch.no_grad(): # decoder input B, _, C = x.shape dec_inp = torch.zeros((B, self.args.pred_len, C)).float().to(self.device) dec_inp = torch.cat([x[:, -self.args.label_len:, :], dec_inp], dim=1).float() # encoder - decoder outputs = torch.zeros((B, self.args.pred_len, C)).float() # .to(self.device) id_list = np.arange(0, B, 500) # validation set size id_list = np.append(id_list, B) for i in range(len(id_list) - 1): outputs[id_list[i]:id_list[i + 1], :, :] = self.model(x[id_list[i]:id_list[i + 1]], None, dec_inp[id_list[i]:id_list[i + 1]], None).detach().cpu() f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, -self.args.pred_len:, f_dim:] pred = outputs true = torch.from_numpy(np.array(y)) batch_y_mark = torch.ones(true.shape) loss = criterion(x.detach().cpu()[:, :, 0], self.args.frequency_map, pred[:, :, 0], true, batch_y_mark) self.model.train() return loss def test(self, setting, test=0): _, train_loader = self._get_data(flag='train') _, test_loader = self._get_data(flag='test') x, _ = train_loader.dataset.last_insample_window() y = test_loader.dataset.timeseries x = torch.tensor(x, dtype=torch.float32).to(self.device) x = x.unsqueeze(-1) if test: print('loading model') self.model.load_state_dict(torch.load(os.path.join('./checkpoints/' + setting, 'checkpoint.pth'))) folder_path = './test_results/' + setting + '/' if not os.path.exists(folder_path): os.makedirs(folder_path) self.model.eval() with torch.no_grad(): B, _, C = x.shape dec_inp = torch.zeros((B, self.args.pred_len, C)).float().to(self.device) dec_inp = torch.cat([x[:, -self.args.label_len:, :], dec_inp], dim=1).float() # encoder - decoder outputs = torch.zeros((B, self.args.pred_len, C)).float().to(self.device) id_list = np.arange(0, B, 1) id_list = np.append(id_list, B) for i in range(len(id_list) - 1): outputs[id_list[i]:id_list[i + 1], :, :] = self.model(x[id_list[i]:id_list[i + 1]], None, dec_inp[id_list[i]:id_list[i + 1]], None) if id_list[i] % 1000 == 0: print(id_list[i]) f_dim = -1 if self.args.features == 'MS' else 0 outputs = outputs[:, -self.args.pred_len:, f_dim:] outputs = outputs.detach().cpu().numpy() preds = outputs trues = y x = x.detach().cpu().numpy() for i in range(0, preds.shape[0], preds.shape[0] // 10): gt = np.concatenate((x[i, :, 0], trues[i]), axis=0) pd = np.concatenate((x[i, :, 0], preds[i, :, 0]), axis=0) visual(gt, pd, os.path.join(folder_path, str(i) + '.pdf')) print('test shape:', preds.shape) # result save folder_path = './m4_results/' + self.args.model + '/' if not os.path.exists(folder_path): os.makedirs(folder_path) forecasts_df = pandas.DataFrame(preds[:, :, 0], columns=[f'V{i + 1}' for i in range(self.args.pred_len)]) forecasts_df.index = test_loader.dataset.ids[:preds.shape[0]] forecasts_df.index.name = 'id' forecasts_df.set_index(forecasts_df.columns[0], inplace=True) forecasts_df.to_csv(folder_path + self.args.seasonal_patterns + '_forecast.csv') print(self.args.model) file_path = './m4_results/' + self.args.model + '/' if 'Weekly_forecast.csv' in os.listdir(file_path) \ and 'Monthly_forecast.csv' in os.listdir(file_path) \ and 'Yearly_forecast.csv' in os.listdir(file_path) \ and 'Daily_forecast.csv' in os.listdir(file_path) \ and 'Hourly_forecast.csv' in os.listdir(file_path) \ and 'Quarterly_forecast.csv' in os.listdir(file_path): m4_summary = M4Summary(file_path, self.args.root_path) # m4_forecast.set_index(m4_winner_forecast.columns[0], inplace=True) smape_results, owa_results, mape, mase = m4_summary.evaluate() print('smape:', smape_results) print('mape:', mape) print('mase:', mase) print('owa:', owa_results) else: print('After all 6 tasks are finished, you can calculate the averaged index') return library/layers/000077500000000000000000000000001443355502200140245ustar00rootroot00000000000000library/layers/AutoCorrelation.py000066400000000000000000000144501443355502200175140ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F import matplotlib.pyplot as plt import numpy as np import math from math import sqrt import os class AutoCorrelation(nn.Module): """ AutoCorrelation Mechanism with the following two phases: (1) period-based dependencies discovery (2) time delay aggregation This block can replace the self-attention family mechanism seamlessly. """ def __init__(self, mask_flag=True, factor=1, scale=None, attention_dropout=0.1, output_attention=False): super(AutoCorrelation, self).__init__() self.factor = factor self.scale = scale self.mask_flag = mask_flag self.output_attention = output_attention self.dropout = nn.Dropout(attention_dropout) def time_delay_agg_training(self, values, corr): """ SpeedUp version of Autocorrelation (a batch-normalization style design) This is for the training phase. """ head = values.shape[1] channel = values.shape[2] length = values.shape[3] # find top k top_k = int(self.factor * math.log(length)) mean_value = torch.mean(torch.mean(corr, dim=1), dim=1) index = torch.topk(torch.mean(mean_value, dim=0), top_k, dim=-1)[1] weights = torch.stack([mean_value[:, index[i]] for i in range(top_k)], dim=-1) # update corr tmp_corr = torch.softmax(weights, dim=-1) # aggregation tmp_values = values delays_agg = torch.zeros_like(values).float() for i in range(top_k): pattern = torch.roll(tmp_values, -int(index[i]), -1) delays_agg = delays_agg + pattern * \ (tmp_corr[:, i].unsqueeze(1).unsqueeze(1).unsqueeze(1).repeat(1, head, channel, length)) return delays_agg def time_delay_agg_inference(self, values, corr): """ SpeedUp version of Autocorrelation (a batch-normalization style design) This is for the inference phase. """ batch = values.shape[0] head = values.shape[1] channel = values.shape[2] length = values.shape[3] # index init init_index = torch.arange(length).unsqueeze(0).unsqueeze(0).unsqueeze(0).repeat(batch, head, channel, 1).cuda() # find top k top_k = int(self.factor * math.log(length)) mean_value = torch.mean(torch.mean(corr, dim=1), dim=1) weights, delay = torch.topk(mean_value, top_k, dim=-1) # update corr tmp_corr = torch.softmax(weights, dim=-1) # aggregation tmp_values = values.repeat(1, 1, 1, 2) delays_agg = torch.zeros_like(values).float() for i in range(top_k): tmp_delay = init_index + delay[:, i].unsqueeze(1).unsqueeze(1).unsqueeze(1).repeat(1, head, channel, length) pattern = torch.gather(tmp_values, dim=-1, index=tmp_delay) delays_agg = delays_agg + pattern * \ (tmp_corr[:, i].unsqueeze(1).unsqueeze(1).unsqueeze(1).repeat(1, head, channel, length)) return delays_agg def time_delay_agg_full(self, values, corr): """ Standard version of Autocorrelation """ batch = values.shape[0] head = values.shape[1] channel = values.shape[2] length = values.shape[3] # index init init_index = torch.arange(length).unsqueeze(0).unsqueeze(0).unsqueeze(0).repeat(batch, head, channel, 1).cuda() # find top k top_k = int(self.factor * math.log(length)) weights, delay = torch.topk(corr, top_k, dim=-1) # update corr tmp_corr = torch.softmax(weights, dim=-1) # aggregation tmp_values = values.repeat(1, 1, 1, 2) delays_agg = torch.zeros_like(values).float() for i in range(top_k): tmp_delay = init_index + delay[..., i].unsqueeze(-1) pattern = torch.gather(tmp_values, dim=-1, index=tmp_delay) delays_agg = delays_agg + pattern * (tmp_corr[..., i].unsqueeze(-1)) return delays_agg def forward(self, queries, keys, values, attn_mask): B, L, H, E = queries.shape _, S, _, D = values.shape if L > S: zeros = torch.zeros_like(queries[:, :(L - S), :]).float() values = torch.cat([values, zeros], dim=1) keys = torch.cat([keys, zeros], dim=1) else: values = values[:, :L, :, :] keys = keys[:, :L, :, :] # period-based dependencies q_fft = torch.fft.rfft(queries.permute(0, 2, 3, 1).contiguous(), dim=-1) k_fft = torch.fft.rfft(keys.permute(0, 2, 3, 1).contiguous(), dim=-1) res = q_fft * torch.conj(k_fft) corr = torch.fft.irfft(res, dim=-1) # time delay agg if self.training: V = self.time_delay_agg_training(values.permute(0, 2, 3, 1).contiguous(), corr).permute(0, 3, 1, 2) else: V = self.time_delay_agg_inference(values.permute(0, 2, 3, 1).contiguous(), corr).permute(0, 3, 1, 2) if self.output_attention: return (V.contiguous(), corr.permute(0, 3, 1, 2)) else: return (V.contiguous(), None) class AutoCorrelationLayer(nn.Module): def __init__(self, correlation, d_model, n_heads, d_keys=None, d_values=None): super(AutoCorrelationLayer, self).__init__() d_keys = d_keys or (d_model // n_heads) d_values = d_values or (d_model // n_heads) self.inner_correlation = correlation self.query_projection = nn.Linear(d_model, d_keys * n_heads) self.key_projection = nn.Linear(d_model, d_keys * n_heads) self.value_projection = nn.Linear(d_model, d_values * n_heads) self.out_projection = nn.Linear(d_values * n_heads, d_model) self.n_heads = n_heads def forward(self, queries, keys, values, attn_mask): B, L, _ = queries.shape _, S, _ = keys.shape H = self.n_heads queries = self.query_projection(queries).view(B, L, H, -1) keys = self.key_projection(keys).view(B, S, H, -1) values = self.value_projection(values).view(B, S, H, -1) out, attn = self.inner_correlation( queries, keys, values, attn_mask ) out = out.view(B, L, -1) return self.out_projection(out), attn library/layers/Autoformer_EncDec.py000066400000000000000000000152571443355502200177340ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F class my_Layernorm(nn.Module): """ Special designed layernorm for the seasonal part """ def __init__(self, channels): super(my_Layernorm, self).__init__() self.layernorm = nn.LayerNorm(channels) def forward(self, x): x_hat = self.layernorm(x) bias = torch.mean(x_hat, dim=1).unsqueeze(1).repeat(1, x.shape[1], 1) return x_hat - bias class moving_avg(nn.Module): """ Moving average block to highlight the trend of time series """ def __init__(self, kernel_size, stride): super(moving_avg, self).__init__() self.kernel_size = kernel_size self.avg = nn.AvgPool1d(kernel_size=kernel_size, stride=stride, padding=0) def forward(self, x): # padding on the both ends of time series front = x[:, 0:1, :].repeat(1, (self.kernel_size - 1) // 2, 1) end = x[:, -1:, :].repeat(1, (self.kernel_size - 1) // 2, 1) x = torch.cat([front, x, end], dim=1) x = self.avg(x.permute(0, 2, 1)) x = x.permute(0, 2, 1) return x class series_decomp(nn.Module): """ Series decomposition block """ def __init__(self, kernel_size): super(series_decomp, self).__init__() self.moving_avg = moving_avg(kernel_size, stride=1) def forward(self, x): moving_mean = self.moving_avg(x) res = x - moving_mean return res, moving_mean class series_decomp_multi(nn.Module): """ Multiple Series decomposition block from FEDformer """ def __init__(self, kernel_size): super(series_decomp_multi, self).__init__() self.kernel_size = kernel_size self.series_decomp = [series_decomp(kernel) for kernel in kernel_size] def forward(self, x): moving_mean = [] res = [] for func in self.series_decomp: sea, moving_avg = func(x) moving_mean.append(moving_avg) res.append(sea) sea = sum(res) / len(res) moving_mean = sum(moving_mean) / len(moving_mean) return sea, moving_mean class EncoderLayer(nn.Module): """ Autoformer encoder layer with the progressive decomposition architecture """ def __init__(self, attention, d_model, d_ff=None, moving_avg=25, dropout=0.1, activation="relu"): super(EncoderLayer, self).__init__() d_ff = d_ff or 4 * d_model self.attention = attention self.conv1 = nn.Conv1d(in_channels=d_model, out_channels=d_ff, kernel_size=1, bias=False) self.conv2 = nn.Conv1d(in_channels=d_ff, out_channels=d_model, kernel_size=1, bias=False) self.decomp1 = series_decomp(moving_avg) self.decomp2 = series_decomp(moving_avg) self.dropout = nn.Dropout(dropout) self.activation = F.relu if activation == "relu" else F.gelu def forward(self, x, attn_mask=None): new_x, attn = self.attention( x, x, x, attn_mask=attn_mask ) x = x + self.dropout(new_x) x, _ = self.decomp1(x) y = x y = self.dropout(self.activation(self.conv1(y.transpose(-1, 1)))) y = self.dropout(self.conv2(y).transpose(-1, 1)) res, _ = self.decomp2(x + y) return res, attn class Encoder(nn.Module): """ Autoformer encoder """ def __init__(self, attn_layers, conv_layers=None, norm_layer=None): super(Encoder, self).__init__() self.attn_layers = nn.ModuleList(attn_layers) self.conv_layers = nn.ModuleList(conv_layers) if conv_layers is not None else None self.norm = norm_layer def forward(self, x, attn_mask=None): attns = [] if self.conv_layers is not None: for attn_layer, conv_layer in zip(self.attn_layers, self.conv_layers): x, attn = attn_layer(x, attn_mask=attn_mask) x = conv_layer(x) attns.append(attn) x, attn = self.attn_layers[-1](x) attns.append(attn) else: for attn_layer in self.attn_layers: x, attn = attn_layer(x, attn_mask=attn_mask) attns.append(attn) if self.norm is not None: x = self.norm(x) return x, attns class DecoderLayer(nn.Module): """ Autoformer decoder layer with the progressive decomposition architecture """ def __init__(self, self_attention, cross_attention, d_model, c_out, d_ff=None, moving_avg=25, dropout=0.1, activation="relu"): super(DecoderLayer, self).__init__() d_ff = d_ff or 4 * d_model self.self_attention = self_attention self.cross_attention = cross_attention self.conv1 = nn.Conv1d(in_channels=d_model, out_channels=d_ff, kernel_size=1, bias=False) self.conv2 = nn.Conv1d(in_channels=d_ff, out_channels=d_model, kernel_size=1, bias=False) self.decomp1 = series_decomp(moving_avg) self.decomp2 = series_decomp(moving_avg) self.decomp3 = series_decomp(moving_avg) self.dropout = nn.Dropout(dropout) self.projection = nn.Conv1d(in_channels=d_model, out_channels=c_out, kernel_size=3, stride=1, padding=1, padding_mode='circular', bias=False) self.activation = F.relu if activation == "relu" else F.gelu def forward(self, x, cross, x_mask=None, cross_mask=None): x = x + self.dropout(self.self_attention( x, x, x, attn_mask=x_mask )[0]) x, trend1 = self.decomp1(x) x = x + self.dropout(self.cross_attention( x, cross, cross, attn_mask=cross_mask )[0]) x, trend2 = self.decomp2(x) y = x y = self.dropout(self.activation(self.conv1(y.transpose(-1, 1)))) y = self.dropout(self.conv2(y).transpose(-1, 1)) x, trend3 = self.decomp3(x + y) residual_trend = trend1 + trend2 + trend3 residual_trend = self.projection(residual_trend.permute(0, 2, 1)).transpose(1, 2) return x, residual_trend class Decoder(nn.Module): """ Autoformer encoder """ def __init__(self, layers, norm_layer=None, projection=None): super(Decoder, self).__init__() self.layers = nn.ModuleList(layers) self.norm = norm_layer self.projection = projection def forward(self, x, cross, x_mask=None, cross_mask=None, trend=None): for layer in self.layers: x, residual_trend = layer(x, cross, x_mask=x_mask, cross_mask=cross_mask) trend = trend + residual_trend if self.norm is not None: x = self.norm(x) if self.projection is not None: x = self.projection(x) return x, trend library/layers/Conv_Blocks.py000066400000000000000000000044771443355502200166140ustar00rootroot00000000000000import torch import torch.nn as nn class Inception_Block_V1(nn.Module): def __init__(self, in_channels, out_channels, num_kernels=6, init_weight=True): super(Inception_Block_V1, self).__init__() self.in_channels = in_channels self.out_channels = out_channels self.num_kernels = num_kernels kernels = [] for i in range(self.num_kernels): kernels.append(nn.Conv2d(in_channels, out_channels, kernel_size=2 * i + 1, padding=i)) self.kernels = nn.ModuleList(kernels) if init_weight: self._initialize_weights() def _initialize_weights(self): for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.constant_(m.bias, 0) def forward(self, x): res_list = [] for i in range(self.num_kernels): res_list.append(self.kernels[i](x)) res = torch.stack(res_list, dim=-1).mean(-1) return res class Inception_Block_V2(nn.Module): def __init__(self, in_channels, out_channels, num_kernels=6, init_weight=True): super(Inception_Block_V2, self).__init__() self.in_channels = in_channels self.out_channels = out_channels self.num_kernels = num_kernels kernels = [] for i in range(self.num_kernels // 2): kernels.append(nn.Conv2d(in_channels, out_channels, kernel_size=[1, 2 * i + 3], padding=[0, i + 1])) kernels.append(nn.Conv2d(in_channels, out_channels, kernel_size=[2 * i + 3, 1], padding=[i + 1, 0])) kernels.append(nn.Conv2d(in_channels, out_channels, kernel_size=1)) self.kernels = nn.ModuleList(kernels) if init_weight: self._initialize_weights() def _initialize_weights(self): for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.constant_(m.bias, 0) def forward(self, x): res_list = [] for i in range(self.num_kernels + 1): res_list.append(self.kernels[i](x)) res = torch.stack(res_list, dim=-1).mean(-1) return res library/layers/Crossformer_EncDec.py000066400000000000000000000103551443355502200201070ustar00rootroot00000000000000import torch import torch.nn as nn from einops import rearrange, repeat from layers.SelfAttention_Family import TwoStageAttentionLayer class SegMerging(nn.Module): def __init__(self, d_model, win_size, norm_layer=nn.LayerNorm): super().__init__() self.d_model = d_model self.win_size = win_size self.linear_trans = nn.Linear(win_size * d_model, d_model) self.norm = norm_layer(win_size * d_model) def forward(self, x): batch_size, ts_d, seg_num, d_model = x.shape pad_num = seg_num % self.win_size if pad_num != 0: pad_num = self.win_size - pad_num x = torch.cat((x, x[:, :, -pad_num:, :]), dim=-2) seg_to_merge = [] for i in range(self.win_size): seg_to_merge.append(x[:, :, i::self.win_size, :]) x = torch.cat(seg_to_merge, -1) x = self.norm(x) x = self.linear_trans(x) return x class scale_block(nn.Module): def __init__(self, configs, win_size, d_model, n_heads, d_ff, depth, dropout, \ seg_num=10, factor=10): super(scale_block, self).__init__() if win_size > 1: self.merge_layer = SegMerging(d_model, win_size, nn.LayerNorm) else: self.merge_layer = None self.encode_layers = nn.ModuleList() for i in range(depth): self.encode_layers.append(TwoStageAttentionLayer(configs, seg_num, factor, d_model, n_heads, \ d_ff, dropout)) def forward(self, x, attn_mask=None, tau=None, delta=None): _, ts_dim, _, _ = x.shape if self.merge_layer is not None: x = self.merge_layer(x) for layer in self.encode_layers: x = layer(x) return x, None class Encoder(nn.Module): def __init__(self, attn_layers): super(Encoder, self).__init__() self.encode_blocks = nn.ModuleList(attn_layers) def forward(self, x): encode_x = [] encode_x.append(x) for block in self.encode_blocks: x, attns = block(x) encode_x.append(x) return encode_x, None class DecoderLayer(nn.Module): def __init__(self, self_attention, cross_attention, seg_len, d_model, d_ff=None, dropout=0.1): super(DecoderLayer, self).__init__() self.self_attention = self_attention self.cross_attention = cross_attention self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) self.MLP1 = nn.Sequential(nn.Linear(d_model, d_model), nn.GELU(), nn.Linear(d_model, d_model)) self.linear_pred = nn.Linear(d_model, seg_len) def forward(self, x, cross): batch = x.shape[0] x = self.self_attention(x) x = rearrange(x, 'b ts_d out_seg_num d_model -> (b ts_d) out_seg_num d_model') cross = rearrange(cross, 'b ts_d in_seg_num d_model -> (b ts_d) in_seg_num d_model') tmp, attn = self.cross_attention(x, cross, cross, None, None, None,) x = x + self.dropout(tmp) y = x = self.norm1(x) y = self.MLP1(y) dec_output = self.norm2(x + y) dec_output = rearrange(dec_output, '(b ts_d) seg_dec_num d_model -> b ts_d seg_dec_num d_model', b=batch) layer_predict = self.linear_pred(dec_output) layer_predict = rearrange(layer_predict, 'b out_d seg_num seg_len -> b (out_d seg_num) seg_len') return dec_output, layer_predict class Decoder(nn.Module): def __init__(self, layers): super(Decoder, self).__init__() self.decode_layers = nn.ModuleList(layers) def forward(self, x, cross): final_predict = None i = 0 ts_d = x.shape[1] for layer in self.decode_layers: cross_enc = cross[i] x, layer_predict = layer(x, cross_enc) if final_predict is None: final_predict = layer_predict else: final_predict = final_predict + layer_predict i += 1 final_predict = rearrange(final_predict, 'b (out_d seg_num) seg_len -> b (seg_num seg_len) out_d', out_d=ts_d) return final_predict library/layers/ETSformer_EncDec.py000066400000000000000000000262031443355502200174500ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F import torch.fft as fft from einops import rearrange, reduce, repeat import math, random from scipy.fftpack import next_fast_len class Transform: def __init__(self, sigma): self.sigma = sigma @torch.no_grad() def transform(self, x): return self.jitter(self.shift(self.scale(x))) def jitter(self, x): return x + (torch.randn(x.shape).to(x.device) * self.sigma) def scale(self, x): return x * (torch.randn(x.size(-1)).to(x.device) * self.sigma + 1) def shift(self, x): return x + (torch.randn(x.size(-1)).to(x.device) * self.sigma) def conv1d_fft(f, g, dim=-1): N = f.size(dim) M = g.size(dim) fast_len = next_fast_len(N + M - 1) F_f = fft.rfft(f, fast_len, dim=dim) F_g = fft.rfft(g, fast_len, dim=dim) F_fg = F_f * F_g.conj() out = fft.irfft(F_fg, fast_len, dim=dim) out = out.roll((-1,), dims=(dim,)) idx = torch.as_tensor(range(fast_len - N, fast_len)).to(out.device) out = out.index_select(dim, idx) return out class ExponentialSmoothing(nn.Module): def __init__(self, dim, nhead, dropout=0.1, aux=False): super().__init__() self._smoothing_weight = nn.Parameter(torch.randn(nhead, 1)) self.v0 = nn.Parameter(torch.randn(1, 1, nhead, dim)) self.dropout = nn.Dropout(dropout) if aux: self.aux_dropout = nn.Dropout(dropout) def forward(self, values, aux_values=None): b, t, h, d = values.shape init_weight, weight = self.get_exponential_weight(t) output = conv1d_fft(self.dropout(values), weight, dim=1) output = init_weight * self.v0 + output if aux_values is not None: aux_weight = weight / (1 - self.weight) * self.weight aux_output = conv1d_fft(self.aux_dropout(aux_values), aux_weight) output = output + aux_output return output def get_exponential_weight(self, T): # Generate array [0, 1, ..., T-1] powers = torch.arange(T, dtype=torch.float, device=self.weight.device) # (1 - \alpha) * \alpha^t, for all t = T-1, T-2, ..., 0] weight = (1 - self.weight) * (self.weight ** torch.flip(powers, dims=(0,))) # \alpha^t for all t = 1, 2, ..., T init_weight = self.weight ** (powers + 1) return rearrange(init_weight, 'h t -> 1 t h 1'), \ rearrange(weight, 'h t -> 1 t h 1') @property def weight(self): return torch.sigmoid(self._smoothing_weight) class Feedforward(nn.Module): def __init__(self, d_model, dim_feedforward, dropout=0.1, activation='sigmoid'): # Implementation of Feedforward model super().__init__() self.linear1 = nn.Linear(d_model, dim_feedforward, bias=False) self.dropout1 = nn.Dropout(dropout) self.linear2 = nn.Linear(dim_feedforward, d_model, bias=False) self.dropout2 = nn.Dropout(dropout) self.activation = getattr(F, activation) def forward(self, x): x = self.linear2(self.dropout1(self.activation(self.linear1(x)))) return self.dropout2(x) class GrowthLayer(nn.Module): def __init__(self, d_model, nhead, d_head=None, dropout=0.1): super().__init__() self.d_head = d_head or (d_model // nhead) self.d_model = d_model self.nhead = nhead self.z0 = nn.Parameter(torch.randn(self.nhead, self.d_head)) self.in_proj = nn.Linear(self.d_model, self.d_head * self.nhead) self.es = ExponentialSmoothing(self.d_head, self.nhead, dropout=dropout) self.out_proj = nn.Linear(self.d_head * self.nhead, self.d_model) assert self.d_head * self.nhead == self.d_model, "d_model must be divisible by nhead" def forward(self, inputs): """ :param inputs: shape: (batch, seq_len, dim) :return: shape: (batch, seq_len, dim) """ b, t, d = inputs.shape values = self.in_proj(inputs).view(b, t, self.nhead, -1) values = torch.cat([repeat(self.z0, 'h d -> b 1 h d', b=b), values], dim=1) values = values[:, 1:] - values[:, :-1] out = self.es(values) out = torch.cat([repeat(self.es.v0, '1 1 h d -> b 1 h d', b=b), out], dim=1) out = rearrange(out, 'b t h d -> b t (h d)') return self.out_proj(out) class FourierLayer(nn.Module): def __init__(self, d_model, pred_len, k=None, low_freq=1): super().__init__() self.d_model = d_model self.pred_len = pred_len self.k = k self.low_freq = low_freq def forward(self, x): """x: (b, t, d)""" b, t, d = x.shape x_freq = fft.rfft(x, dim=1) if t % 2 == 0: x_freq = x_freq[:, self.low_freq:-1] f = fft.rfftfreq(t)[self.low_freq:-1] else: x_freq = x_freq[:, self.low_freq:] f = fft.rfftfreq(t)[self.low_freq:] x_freq, index_tuple = self.topk_freq(x_freq) f = repeat(f, 'f -> b f d', b=x_freq.size(0), d=x_freq.size(2)) f = rearrange(f[index_tuple], 'b f d -> b f () d').to(x_freq.device) return self.extrapolate(x_freq, f, t) def extrapolate(self, x_freq, f, t): x_freq = torch.cat([x_freq, x_freq.conj()], dim=1) f = torch.cat([f, -f], dim=1) t_val = rearrange(torch.arange(t + self.pred_len, dtype=torch.float), 't -> () () t ()').to(x_freq.device) amp = rearrange(x_freq.abs() / t, 'b f d -> b f () d') phase = rearrange(x_freq.angle(), 'b f d -> b f () d') x_time = amp * torch.cos(2 * math.pi * f * t_val + phase) return reduce(x_time, 'b f t d -> b t d', 'sum') def topk_freq(self, x_freq): values, indices = torch.topk(x_freq.abs(), self.k, dim=1, largest=True, sorted=True) mesh_a, mesh_b = torch.meshgrid(torch.arange(x_freq.size(0)), torch.arange(x_freq.size(2))) index_tuple = (mesh_a.unsqueeze(1), indices, mesh_b.unsqueeze(1)) x_freq = x_freq[index_tuple] return x_freq, index_tuple class LevelLayer(nn.Module): def __init__(self, d_model, c_out, dropout=0.1): super().__init__() self.d_model = d_model self.c_out = c_out self.es = ExponentialSmoothing(1, self.c_out, dropout=dropout, aux=True) self.growth_pred = nn.Linear(self.d_model, self.c_out) self.season_pred = nn.Linear(self.d_model, self.c_out) def forward(self, level, growth, season): b, t, _ = level.shape growth = self.growth_pred(growth).view(b, t, self.c_out, 1) season = self.season_pred(season).view(b, t, self.c_out, 1) growth = growth.view(b, t, self.c_out, 1) season = season.view(b, t, self.c_out, 1) level = level.view(b, t, self.c_out, 1) out = self.es(level - season, aux_values=growth) out = rearrange(out, 'b t h d -> b t (h d)') return out class EncoderLayer(nn.Module): def __init__(self, d_model, nhead, c_out, seq_len, pred_len, k, dim_feedforward=None, dropout=0.1, activation='sigmoid', layer_norm_eps=1e-5): super().__init__() self.d_model = d_model self.nhead = nhead self.c_out = c_out self.seq_len = seq_len self.pred_len = pred_len dim_feedforward = dim_feedforward or 4 * d_model self.dim_feedforward = dim_feedforward self.growth_layer = GrowthLayer(d_model, nhead, dropout=dropout) self.seasonal_layer = FourierLayer(d_model, pred_len, k=k) self.level_layer = LevelLayer(d_model, c_out, dropout=dropout) # Implementation of Feedforward model self.ff = Feedforward(d_model, dim_feedforward, dropout=dropout, activation=activation) self.norm1 = nn.LayerNorm(d_model, eps=layer_norm_eps) self.norm2 = nn.LayerNorm(d_model, eps=layer_norm_eps) self.dropout1 = nn.Dropout(dropout) self.dropout2 = nn.Dropout(dropout) def forward(self, res, level, attn_mask=None): season = self._season_block(res) res = res - season[:, :-self.pred_len] growth = self._growth_block(res) res = self.norm1(res - growth[:, 1:]) res = self.norm2(res + self.ff(res)) level = self.level_layer(level, growth[:, :-1], season[:, :-self.pred_len]) return res, level, growth, season def _growth_block(self, x): x = self.growth_layer(x) return self.dropout1(x) def _season_block(self, x): x = self.seasonal_layer(x) return self.dropout2(x) class Encoder(nn.Module): def __init__(self, layers): super().__init__() self.layers = nn.ModuleList(layers) def forward(self, res, level, attn_mask=None): growths = [] seasons = [] for layer in self.layers: res, level, growth, season = layer(res, level, attn_mask=None) growths.append(growth) seasons.append(season) return level, growths, seasons class DampingLayer(nn.Module): def __init__(self, pred_len, nhead, dropout=0.1): super().__init__() self.pred_len = pred_len self.nhead = nhead self._damping_factor = nn.Parameter(torch.randn(1, nhead)) self.dropout = nn.Dropout(dropout) def forward(self, x): x = repeat(x, 'b 1 d -> b t d', t=self.pred_len) b, t, d = x.shape powers = torch.arange(self.pred_len).to(self._damping_factor.device) + 1 powers = powers.view(self.pred_len, 1) damping_factors = self.damping_factor ** powers damping_factors = damping_factors.cumsum(dim=0) x = x.view(b, t, self.nhead, -1) x = self.dropout(x) * damping_factors.unsqueeze(-1) return x.view(b, t, d) @property def damping_factor(self): return torch.sigmoid(self._damping_factor) class DecoderLayer(nn.Module): def __init__(self, d_model, nhead, c_out, pred_len, dropout=0.1): super().__init__() self.d_model = d_model self.nhead = nhead self.c_out = c_out self.pred_len = pred_len self.growth_damping = DampingLayer(pred_len, nhead, dropout=dropout) self.dropout1 = nn.Dropout(dropout) def forward(self, growth, season): growth_horizon = self.growth_damping(growth[:, -1:]) growth_horizon = self.dropout1(growth_horizon) seasonal_horizon = season[:, -self.pred_len:] return growth_horizon, seasonal_horizon class Decoder(nn.Module): def __init__(self, layers): super().__init__() self.d_model = layers[0].d_model self.c_out = layers[0].c_out self.pred_len = layers[0].pred_len self.nhead = layers[0].nhead self.layers = nn.ModuleList(layers) self.pred = nn.Linear(self.d_model, self.c_out) def forward(self, growths, seasons): growth_repr = [] season_repr = [] for idx, layer in enumerate(self.layers): growth_horizon, season_horizon = layer(growths[idx], seasons[idx]) growth_repr.append(growth_horizon) season_repr.append(season_horizon) growth_repr = sum(growth_repr) season_repr = sum(season_repr) return self.pred(growth_repr), self.pred(season_repr) library/layers/Embed.py000066400000000000000000000144011443355502200154120ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F from torch.nn.utils import weight_norm import math class PositionalEmbedding(nn.Module): def __init__(self, d_model, max_len=5000): super(PositionalEmbedding, self).__init__() # Compute the positional encodings once in log space. pe = torch.zeros(max_len, d_model).float() pe.require_grad = False position = torch.arange(0, max_len).float().unsqueeze(1) div_term = (torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model)).exp() pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(0) self.register_buffer('pe', pe) def forward(self, x): return self.pe[:, :x.size(1)] class TokenEmbedding(nn.Module): def __init__(self, c_in, d_model): super(TokenEmbedding, self).__init__() padding = 1 if torch.__version__ >= '1.5.0' else 2 self.tokenConv = nn.Conv1d(in_channels=c_in, out_channels=d_model, kernel_size=3, padding=padding, padding_mode='circular', bias=False) for m in self.modules(): if isinstance(m, nn.Conv1d): nn.init.kaiming_normal_( m.weight, mode='fan_in', nonlinearity='leaky_relu') def forward(self, x): x = self.tokenConv(x.permute(0, 2, 1)).transpose(1, 2) return x class FixedEmbedding(nn.Module): def __init__(self, c_in, d_model): super(FixedEmbedding, self).__init__() w = torch.zeros(c_in, d_model).float() w.require_grad = False position = torch.arange(0, c_in).float().unsqueeze(1) div_term = (torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model)).exp() w[:, 0::2] = torch.sin(position * div_term) w[:, 1::2] = torch.cos(position * div_term) self.emb = nn.Embedding(c_in, d_model) self.emb.weight = nn.Parameter(w, requires_grad=False) def forward(self, x): return self.emb(x).detach() class TemporalEmbedding(nn.Module): def __init__(self, d_model, embed_type='fixed', freq='h'): super(TemporalEmbedding, self).__init__() minute_size = 4 hour_size = 24 weekday_size = 7 day_size = 32 month_size = 13 Embed = FixedEmbedding if embed_type == 'fixed' else nn.Embedding if freq == 't': self.minute_embed = Embed(minute_size, d_model) self.hour_embed = Embed(hour_size, d_model) self.weekday_embed = Embed(weekday_size, d_model) self.day_embed = Embed(day_size, d_model) self.month_embed = Embed(month_size, d_model) def forward(self, x): x = x.long() minute_x = self.minute_embed(x[:, :, 4]) if hasattr( self, 'minute_embed') else 0. hour_x = self.hour_embed(x[:, :, 3]) weekday_x = self.weekday_embed(x[:, :, 2]) day_x = self.day_embed(x[:, :, 1]) month_x = self.month_embed(x[:, :, 0]) return hour_x + weekday_x + day_x + month_x + minute_x class TimeFeatureEmbedding(nn.Module): def __init__(self, d_model, embed_type='timeF', freq='h'): super(TimeFeatureEmbedding, self).__init__() freq_map = {'h': 4, 't': 5, 's': 6, 'm': 1, 'a': 1, 'w': 2, 'd': 3, 'b': 3} d_inp = freq_map[freq] self.embed = nn.Linear(d_inp, d_model, bias=False) def forward(self, x): return self.embed(x) class DataEmbedding(nn.Module): def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropout=0.1): super(DataEmbedding, self).__init__() self.value_embedding = TokenEmbedding(c_in=c_in, d_model=d_model) self.position_embedding = PositionalEmbedding(d_model=d_model) self.temporal_embedding = TemporalEmbedding(d_model=d_model, embed_type=embed_type, freq=freq) if embed_type != 'timeF' else TimeFeatureEmbedding( d_model=d_model, embed_type=embed_type, freq=freq) self.dropout = nn.Dropout(p=dropout) def forward(self, x, x_mark): if x_mark is None: x = self.value_embedding(x) + self.position_embedding(x) else: x = self.value_embedding( x) + self.temporal_embedding(x_mark) + self.position_embedding(x) return self.dropout(x) class DataEmbedding_wo_pos(nn.Module): def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropout=0.1): super(DataEmbedding_wo_pos, self).__init__() self.value_embedding = TokenEmbedding(c_in=c_in, d_model=d_model) self.position_embedding = PositionalEmbedding(d_model=d_model) self.temporal_embedding = TemporalEmbedding(d_model=d_model, embed_type=embed_type, freq=freq) if embed_type != 'timeF' else TimeFeatureEmbedding( d_model=d_model, embed_type=embed_type, freq=freq) self.dropout = nn.Dropout(p=dropout) def forward(self, x, x_mark): if x_mark is None: x = self.value_embedding(x) else: x = self.value_embedding(x) + self.temporal_embedding(x_mark) return self.dropout(x) class PatchEmbedding(nn.Module): def __init__(self, d_model, patch_len, stride, padding, dropout): super(PatchEmbedding, self).__init__() # Patching self.patch_len = patch_len self.stride = stride self.padding_patch_layer = nn.ReplicationPad1d((0, padding)) # Backbone, Input encoding: projection of feature vectors onto a d-dim vector space self.value_embedding = nn.Linear(patch_len, d_model, bias=False) # Positional embedding self.position_embedding = PositionalEmbedding(d_model) # Residual dropout self.dropout = nn.Dropout(dropout) def forward(self, x): # do patching n_vars = x.shape[1] x = self.padding_patch_layer(x) x = x.unfold(dimension=-1, size=self.patch_len, step=self.stride) x = torch.reshape(x, (x.shape[0] * x.shape[1], x.shape[2], x.shape[3])) # Input encoding x = self.value_embedding(x) + self.position_embedding(x) return self.dropout(x), n_vars library/layers/FourierCorrelation.py000066400000000000000000000161651443355502200202240ustar00rootroot00000000000000# coding=utf-8 # author=maziqing # email=maziqing.mzq@alibaba-inc.com import numpy as np import torch import torch.nn as nn def get_frequency_modes(seq_len, modes=64, mode_select_method='random'): """ get modes on frequency domain: 'random' means sampling randomly; 'else' means sampling the lowest modes; """ modes = min(modes, seq_len // 2) if mode_select_method == 'random': index = list(range(0, seq_len // 2)) np.random.shuffle(index) index = index[:modes] else: index = list(range(0, modes)) index.sort() return index # ########## fourier layer ############# class FourierBlock(nn.Module): def __init__(self, in_channels, out_channels, seq_len, modes=0, mode_select_method='random'): super(FourierBlock, self).__init__() print('fourier enhanced block used!') """ 1D Fourier block. It performs representation learning on frequency domain, it does FFT, linear transform, and Inverse FFT. """ # get modes on frequency domain self.index = get_frequency_modes(seq_len, modes=modes, mode_select_method=mode_select_method) print('modes={}, index={}'.format(modes, self.index)) self.scale = (1 / (in_channels * out_channels)) self.weights1 = nn.Parameter( self.scale * torch.rand(8, in_channels // 8, out_channels // 8, len(self.index), dtype=torch.float)) self.weights2 = nn.Parameter( self.scale * torch.rand(8, in_channels // 8, out_channels // 8, len(self.index), dtype=torch.float)) # Complex multiplication def compl_mul1d(self, order, x, weights): x_flag = True w_flag = True if not torch.is_complex(x): x_flag = False x = torch.complex(x, torch.zeros_like(x).to(x.device)) if not torch.is_complex(weights): w_flag = False weights = torch.complex(weights, torch.zeros_like(weights).to(weights.device)) if x_flag or w_flag: return torch.complex(torch.einsum(order, x.real, weights.real) - torch.einsum(order, x.imag, weights.imag), torch.einsum(order, x.real, weights.imag) + torch.einsum(order, x.imag, weights.real)) else: return torch.einsum(order, x.real, weights.real) def forward(self, q, k, v, mask): # size = [B, L, H, E] B, L, H, E = q.shape x = q.permute(0, 2, 3, 1) # Compute Fourier coefficients x_ft = torch.fft.rfft(x, dim=-1) # Perform Fourier neural operations out_ft = torch.zeros(B, H, E, L // 2 + 1, device=x.device, dtype=torch.cfloat) for wi, i in enumerate(self.index): if i >= x_ft.shape[3] or wi >= out_ft.shape[3]: continue out_ft[:, :, :, wi] = self.compl_mul1d("bhi,hio->bho", x_ft[:, :, :, i], torch.complex(self.weights1, self.weights2)[:, :, :, wi]) # Return to time domain x = torch.fft.irfft(out_ft, n=x.size(-1)) return (x, None) # ########## Fourier Cross Former #################### class FourierCrossAttention(nn.Module): def __init__(self, in_channels, out_channels, seq_len_q, seq_len_kv, modes=64, mode_select_method='random', activation='tanh', policy=0): super(FourierCrossAttention, self).__init__() print(' fourier enhanced cross attention used!') """ 1D Fourier Cross Attention layer. It does FFT, linear transform, attention mechanism and Inverse FFT. """ self.activation = activation self.in_channels = in_channels self.out_channels = out_channels # get modes for queries and keys (& values) on frequency domain self.index_q = get_frequency_modes(seq_len_q, modes=modes, mode_select_method=mode_select_method) self.index_kv = get_frequency_modes(seq_len_kv, modes=modes, mode_select_method=mode_select_method) print('modes_q={}, index_q={}'.format(len(self.index_q), self.index_q)) print('modes_kv={}, index_kv={}'.format(len(self.index_kv), self.index_kv)) self.scale = (1 / (in_channels * out_channels)) self.weights1 = nn.Parameter( self.scale * torch.rand(8, in_channels // 8, out_channels // 8, len(self.index_q), dtype=torch.float)) self.weights2 = nn.Parameter( self.scale * torch.rand(8, in_channels // 8, out_channels // 8, len(self.index_q), dtype=torch.float)) # Complex multiplication def compl_mul1d(self, order, x, weights): x_flag = True w_flag = True if not torch.is_complex(x): x_flag = False x = torch.complex(x, torch.zeros_like(x).to(x.device)) if not torch.is_complex(weights): w_flag = False weights = torch.complex(weights, torch.zeros_like(weights).to(weights.device)) if x_flag or w_flag: return torch.complex(torch.einsum(order, x.real, weights.real) - torch.einsum(order, x.imag, weights.imag), torch.einsum(order, x.real, weights.imag) + torch.einsum(order, x.imag, weights.real)) else: return torch.einsum(order, x.real, weights.real) def forward(self, q, k, v, mask): # size = [B, L, H, E] B, L, H, E = q.shape xq = q.permute(0, 2, 3, 1) # size = [B, H, E, L] xk = k.permute(0, 2, 3, 1) xv = v.permute(0, 2, 3, 1) # Compute Fourier coefficients xq_ft_ = torch.zeros(B, H, E, len(self.index_q), device=xq.device, dtype=torch.cfloat) xq_ft = torch.fft.rfft(xq, dim=-1) for i, j in enumerate(self.index_q): if j >= xq_ft.shape[3]: continue xq_ft_[:, :, :, i] = xq_ft[:, :, :, j] xk_ft_ = torch.zeros(B, H, E, len(self.index_kv), device=xq.device, dtype=torch.cfloat) xk_ft = torch.fft.rfft(xk, dim=-1) for i, j in enumerate(self.index_kv): if j >= xk_ft.shape[3]: continue xk_ft_[:, :, :, i] = xk_ft[:, :, :, j] # perform attention mechanism on frequency domain xqk_ft = (self.compl_mul1d("bhex,bhey->bhxy", xq_ft_, xk_ft_)) if self.activation == 'tanh': xqk_ft = torch.complex(xqk_ft.real.tanh(), xqk_ft.imag.tanh()) elif self.activation == 'softmax': xqk_ft = torch.softmax(abs(xqk_ft), dim=-1) xqk_ft = torch.complex(xqk_ft, torch.zeros_like(xqk_ft)) else: raise Exception('{} actiation function is not implemented'.format(self.activation)) xqkv_ft = self.compl_mul1d("bhxy,bhey->bhex", xqk_ft, xk_ft_) xqkvw = self.compl_mul1d("bhex,heox->bhox", xqkv_ft, torch.complex(self.weights1, self.weights2)) out_ft = torch.zeros(B, H, E, L // 2 + 1, device=xq.device, dtype=torch.cfloat) for i, j in enumerate(self.index_q): if i >= xqkvw.shape[3] or j >= out_ft.shape[3]: continue out_ft[:, :, :, j] = xqkvw[:, :, :, i] # Return to time domain out = torch.fft.irfft(out_ft / self.in_channels / self.out_channels, n=xq.size(-1)) return (out, None) library/layers/MultiWaveletCorrelation.py000066400000000000000000000547771443355502200212460ustar00rootroot00000000000000import torch import numpy as np import torch.nn as nn import torch.nn.functional as F from torch import Tensor from typing import List, Tuple import math from functools import partial from torch import nn, einsum, diagonal from math import log2, ceil import pdb from sympy import Poly, legendre, Symbol, chebyshevt from scipy.special import eval_legendre def legendreDer(k, x): def _legendre(k, x): return (2 * k + 1) * eval_legendre(k, x) out = 0 for i in np.arange(k - 1, -1, -2): out += _legendre(i, x) return out def phi_(phi_c, x, lb=0, ub=1): mask = np.logical_or(x < lb, x > ub) * 1.0 return np.polynomial.polynomial.Polynomial(phi_c)(x) * (1 - mask) def get_phi_psi(k, base): x = Symbol('x') phi_coeff = np.zeros((k, k)) phi_2x_coeff = np.zeros((k, k)) if base == 'legendre': for ki in range(k): coeff_ = Poly(legendre(ki, 2 * x - 1), x).all_coeffs() phi_coeff[ki, :ki + 1] = np.flip(np.sqrt(2 * ki + 1) * np.array(coeff_).astype(np.float64)) coeff_ = Poly(legendre(ki, 4 * x - 1), x).all_coeffs() phi_2x_coeff[ki, :ki + 1] = np.flip(np.sqrt(2) * np.sqrt(2 * ki + 1) * np.array(coeff_).astype(np.float64)) psi1_coeff = np.zeros((k, k)) psi2_coeff = np.zeros((k, k)) for ki in range(k): psi1_coeff[ki, :] = phi_2x_coeff[ki, :] for i in range(k): a = phi_2x_coeff[ki, :ki + 1] b = phi_coeff[i, :i + 1] prod_ = np.convolve(a, b) prod_[np.abs(prod_) < 1e-8] = 0 proj_ = (prod_ * 1 / (np.arange(len(prod_)) + 1) * np.power(0.5, 1 + np.arange(len(prod_)))).sum() psi1_coeff[ki, :] -= proj_ * phi_coeff[i, :] psi2_coeff[ki, :] -= proj_ * phi_coeff[i, :] for j in range(ki): a = phi_2x_coeff[ki, :ki + 1] b = psi1_coeff[j, :] prod_ = np.convolve(a, b) prod_[np.abs(prod_) < 1e-8] = 0 proj_ = (prod_ * 1 / (np.arange(len(prod_)) + 1) * np.power(0.5, 1 + np.arange(len(prod_)))).sum() psi1_coeff[ki, :] -= proj_ * psi1_coeff[j, :] psi2_coeff[ki, :] -= proj_ * psi2_coeff[j, :] a = psi1_coeff[ki, :] prod_ = np.convolve(a, a) prod_[np.abs(prod_) < 1e-8] = 0 norm1 = (prod_ * 1 / (np.arange(len(prod_)) + 1) * np.power(0.5, 1 + np.arange(len(prod_)))).sum() a = psi2_coeff[ki, :] prod_ = np.convolve(a, a) prod_[np.abs(prod_) < 1e-8] = 0 norm2 = (prod_ * 1 / (np.arange(len(prod_)) + 1) * (1 - np.power(0.5, 1 + np.arange(len(prod_))))).sum() norm_ = np.sqrt(norm1 + norm2) psi1_coeff[ki, :] /= norm_ psi2_coeff[ki, :] /= norm_ psi1_coeff[np.abs(psi1_coeff) < 1e-8] = 0 psi2_coeff[np.abs(psi2_coeff) < 1e-8] = 0 phi = [np.poly1d(np.flip(phi_coeff[i, :])) for i in range(k)] psi1 = [np.poly1d(np.flip(psi1_coeff[i, :])) for i in range(k)] psi2 = [np.poly1d(np.flip(psi2_coeff[i, :])) for i in range(k)] elif base == 'chebyshev': for ki in range(k): if ki == 0: phi_coeff[ki, :ki + 1] = np.sqrt(2 / np.pi) phi_2x_coeff[ki, :ki + 1] = np.sqrt(2 / np.pi) * np.sqrt(2) else: coeff_ = Poly(chebyshevt(ki, 2 * x - 1), x).all_coeffs() phi_coeff[ki, :ki + 1] = np.flip(2 / np.sqrt(np.pi) * np.array(coeff_).astype(np.float64)) coeff_ = Poly(chebyshevt(ki, 4 * x - 1), x).all_coeffs() phi_2x_coeff[ki, :ki + 1] = np.flip( np.sqrt(2) * 2 / np.sqrt(np.pi) * np.array(coeff_).astype(np.float64)) phi = [partial(phi_, phi_coeff[i, :]) for i in range(k)] x = Symbol('x') kUse = 2 * k roots = Poly(chebyshevt(kUse, 2 * x - 1)).all_roots() x_m = np.array([rt.evalf(20) for rt in roots]).astype(np.float64) # x_m[x_m==0.5] = 0.5 + 1e-8 # add small noise to avoid the case of 0.5 belonging to both phi(2x) and phi(2x-1) # not needed for our purpose here, we use even k always to avoid wm = np.pi / kUse / 2 psi1_coeff = np.zeros((k, k)) psi2_coeff = np.zeros((k, k)) psi1 = [[] for _ in range(k)] psi2 = [[] for _ in range(k)] for ki in range(k): psi1_coeff[ki, :] = phi_2x_coeff[ki, :] for i in range(k): proj_ = (wm * phi[i](x_m) * np.sqrt(2) * phi[ki](2 * x_m)).sum() psi1_coeff[ki, :] -= proj_ * phi_coeff[i, :] psi2_coeff[ki, :] -= proj_ * phi_coeff[i, :] for j in range(ki): proj_ = (wm * psi1[j](x_m) * np.sqrt(2) * phi[ki](2 * x_m)).sum() psi1_coeff[ki, :] -= proj_ * psi1_coeff[j, :] psi2_coeff[ki, :] -= proj_ * psi2_coeff[j, :] psi1[ki] = partial(phi_, psi1_coeff[ki, :], lb=0, ub=0.5) psi2[ki] = partial(phi_, psi2_coeff[ki, :], lb=0.5, ub=1) norm1 = (wm * psi1[ki](x_m) * psi1[ki](x_m)).sum() norm2 = (wm * psi2[ki](x_m) * psi2[ki](x_m)).sum() norm_ = np.sqrt(norm1 + norm2) psi1_coeff[ki, :] /= norm_ psi2_coeff[ki, :] /= norm_ psi1_coeff[np.abs(psi1_coeff) < 1e-8] = 0 psi2_coeff[np.abs(psi2_coeff) < 1e-8] = 0 psi1[ki] = partial(phi_, psi1_coeff[ki, :], lb=0, ub=0.5 + 1e-16) psi2[ki] = partial(phi_, psi2_coeff[ki, :], lb=0.5 + 1e-16, ub=1) return phi, psi1, psi2 def get_filter(base, k): def psi(psi1, psi2, i, inp): mask = (inp <= 0.5) * 1.0 return psi1[i](inp) * mask + psi2[i](inp) * (1 - mask) if base not in ['legendre', 'chebyshev']: raise Exception('Base not supported') x = Symbol('x') H0 = np.zeros((k, k)) H1 = np.zeros((k, k)) G0 = np.zeros((k, k)) G1 = np.zeros((k, k)) PHI0 = np.zeros((k, k)) PHI1 = np.zeros((k, k)) phi, psi1, psi2 = get_phi_psi(k, base) if base == 'legendre': roots = Poly(legendre(k, 2 * x - 1)).all_roots() x_m = np.array([rt.evalf(20) for rt in roots]).astype(np.float64) wm = 1 / k / legendreDer(k, 2 * x_m - 1) / eval_legendre(k - 1, 2 * x_m - 1) for ki in range(k): for kpi in range(k): H0[ki, kpi] = 1 / np.sqrt(2) * (wm * phi[ki](x_m / 2) * phi[kpi](x_m)).sum() G0[ki, kpi] = 1 / np.sqrt(2) * (wm * psi(psi1, psi2, ki, x_m / 2) * phi[kpi](x_m)).sum() H1[ki, kpi] = 1 / np.sqrt(2) * (wm * phi[ki]((x_m + 1) / 2) * phi[kpi](x_m)).sum() G1[ki, kpi] = 1 / np.sqrt(2) * (wm * psi(psi1, psi2, ki, (x_m + 1) / 2) * phi[kpi](x_m)).sum() PHI0 = np.eye(k) PHI1 = np.eye(k) elif base == 'chebyshev': x = Symbol('x') kUse = 2 * k roots = Poly(chebyshevt(kUse, 2 * x - 1)).all_roots() x_m = np.array([rt.evalf(20) for rt in roots]).astype(np.float64) # x_m[x_m==0.5] = 0.5 + 1e-8 # add small noise to avoid the case of 0.5 belonging to both phi(2x) and phi(2x-1) # not needed for our purpose here, we use even k always to avoid wm = np.pi / kUse / 2 for ki in range(k): for kpi in range(k): H0[ki, kpi] = 1 / np.sqrt(2) * (wm * phi[ki](x_m / 2) * phi[kpi](x_m)).sum() G0[ki, kpi] = 1 / np.sqrt(2) * (wm * psi(psi1, psi2, ki, x_m / 2) * phi[kpi](x_m)).sum() H1[ki, kpi] = 1 / np.sqrt(2) * (wm * phi[ki]((x_m + 1) / 2) * phi[kpi](x_m)).sum() G1[ki, kpi] = 1 / np.sqrt(2) * (wm * psi(psi1, psi2, ki, (x_m + 1) / 2) * phi[kpi](x_m)).sum() PHI0[ki, kpi] = (wm * phi[ki](2 * x_m) * phi[kpi](2 * x_m)).sum() * 2 PHI1[ki, kpi] = (wm * phi[ki](2 * x_m - 1) * phi[kpi](2 * x_m - 1)).sum() * 2 PHI0[np.abs(PHI0) < 1e-8] = 0 PHI1[np.abs(PHI1) < 1e-8] = 0 H0[np.abs(H0) < 1e-8] = 0 H1[np.abs(H1) < 1e-8] = 0 G0[np.abs(G0) < 1e-8] = 0 G1[np.abs(G1) < 1e-8] = 0 return H0, H1, G0, G1, PHI0, PHI1 class MultiWaveletTransform(nn.Module): """ 1D multiwavelet block. """ def __init__(self, ich=1, k=8, alpha=16, c=128, nCZ=1, L=0, base='legendre', attention_dropout=0.1): super(MultiWaveletTransform, self).__init__() print('base', base) self.k = k self.c = c self.L = L self.nCZ = nCZ self.Lk0 = nn.Linear(ich, c * k) self.Lk1 = nn.Linear(c * k, ich) self.ich = ich self.MWT_CZ = nn.ModuleList(MWT_CZ1d(k, alpha, L, c, base) for i in range(nCZ)) def forward(self, queries, keys, values, attn_mask): B, L, H, E = queries.shape _, S, _, D = values.shape if L > S: zeros = torch.zeros_like(queries[:, :(L - S), :]).float() values = torch.cat([values, zeros], dim=1) keys = torch.cat([keys, zeros], dim=1) else: values = values[:, :L, :, :] keys = keys[:, :L, :, :] values = values.view(B, L, -1) V = self.Lk0(values).view(B, L, self.c, -1) for i in range(self.nCZ): V = self.MWT_CZ[i](V) if i < self.nCZ - 1: V = F.relu(V) V = self.Lk1(V.view(B, L, -1)) V = V.view(B, L, -1, D) return (V.contiguous(), None) class MultiWaveletCross(nn.Module): """ 1D Multiwavelet Cross Attention layer. """ def __init__(self, in_channels, out_channels, seq_len_q, seq_len_kv, modes, c=64, k=8, ich=512, L=0, base='legendre', mode_select_method='random', initializer=None, activation='tanh', **kwargs): super(MultiWaveletCross, self).__init__() print('base', base) self.c = c self.k = k self.L = L H0, H1, G0, G1, PHI0, PHI1 = get_filter(base, k) H0r = H0 @ PHI0 G0r = G0 @ PHI0 H1r = H1 @ PHI1 G1r = G1 @ PHI1 H0r[np.abs(H0r) < 1e-8] = 0 H1r[np.abs(H1r) < 1e-8] = 0 G0r[np.abs(G0r) < 1e-8] = 0 G1r[np.abs(G1r) < 1e-8] = 0 self.max_item = 3 self.attn1 = FourierCrossAttentionW(in_channels=in_channels, out_channels=out_channels, seq_len_q=seq_len_q, seq_len_kv=seq_len_kv, modes=modes, activation=activation, mode_select_method=mode_select_method) self.attn2 = FourierCrossAttentionW(in_channels=in_channels, out_channels=out_channels, seq_len_q=seq_len_q, seq_len_kv=seq_len_kv, modes=modes, activation=activation, mode_select_method=mode_select_method) self.attn3 = FourierCrossAttentionW(in_channels=in_channels, out_channels=out_channels, seq_len_q=seq_len_q, seq_len_kv=seq_len_kv, modes=modes, activation=activation, mode_select_method=mode_select_method) self.attn4 = FourierCrossAttentionW(in_channels=in_channels, out_channels=out_channels, seq_len_q=seq_len_q, seq_len_kv=seq_len_kv, modes=modes, activation=activation, mode_select_method=mode_select_method) self.T0 = nn.Linear(k, k) self.register_buffer('ec_s', torch.Tensor( np.concatenate((H0.T, H1.T), axis=0))) self.register_buffer('ec_d', torch.Tensor( np.concatenate((G0.T, G1.T), axis=0))) self.register_buffer('rc_e', torch.Tensor( np.concatenate((H0r, G0r), axis=0))) self.register_buffer('rc_o', torch.Tensor( np.concatenate((H1r, G1r), axis=0))) self.Lk = nn.Linear(ich, c * k) self.Lq = nn.Linear(ich, c * k) self.Lv = nn.Linear(ich, c * k) self.out = nn.Linear(c * k, ich) self.modes1 = modes def forward(self, q, k, v, mask=None): B, N, H, E = q.shape # (B, N, H, E) torch.Size([3, 768, 8, 2]) _, S, _, _ = k.shape # (B, S, H, E) torch.Size([3, 96, 8, 2]) q = q.view(q.shape[0], q.shape[1], -1) k = k.view(k.shape[0], k.shape[1], -1) v = v.view(v.shape[0], v.shape[1], -1) q = self.Lq(q) q = q.view(q.shape[0], q.shape[1], self.c, self.k) k = self.Lk(k) k = k.view(k.shape[0], k.shape[1], self.c, self.k) v = self.Lv(v) v = v.view(v.shape[0], v.shape[1], self.c, self.k) if N > S: zeros = torch.zeros_like(q[:, :(N - S), :]).float() v = torch.cat([v, zeros], dim=1) k = torch.cat([k, zeros], dim=1) else: v = v[:, :N, :, :] k = k[:, :N, :, :] ns = math.floor(np.log2(N)) nl = pow(2, math.ceil(np.log2(N))) extra_q = q[:, 0:nl - N, :, :] extra_k = k[:, 0:nl - N, :, :] extra_v = v[:, 0:nl - N, :, :] q = torch.cat([q, extra_q], 1) k = torch.cat([k, extra_k], 1) v = torch.cat([v, extra_v], 1) Ud_q = torch.jit.annotate(List[Tuple[Tensor]], []) Ud_k = torch.jit.annotate(List[Tuple[Tensor]], []) Ud_v = torch.jit.annotate(List[Tuple[Tensor]], []) Us_q = torch.jit.annotate(List[Tensor], []) Us_k = torch.jit.annotate(List[Tensor], []) Us_v = torch.jit.annotate(List[Tensor], []) Ud = torch.jit.annotate(List[Tensor], []) Us = torch.jit.annotate(List[Tensor], []) # decompose for i in range(ns - self.L): # print('q shape',q.shape) d, q = self.wavelet_transform(q) Ud_q += [tuple([d, q])] Us_q += [d] for i in range(ns - self.L): d, k = self.wavelet_transform(k) Ud_k += [tuple([d, k])] Us_k += [d] for i in range(ns - self.L): d, v = self.wavelet_transform(v) Ud_v += [tuple([d, v])] Us_v += [d] for i in range(ns - self.L): dk, sk = Ud_k[i], Us_k[i] dq, sq = Ud_q[i], Us_q[i] dv, sv = Ud_v[i], Us_v[i] Ud += [self.attn1(dq[0], dk[0], dv[0], mask)[0] + self.attn2(dq[1], dk[1], dv[1], mask)[0]] Us += [self.attn3(sq, sk, sv, mask)[0]] v = self.attn4(q, k, v, mask)[0] # reconstruct for i in range(ns - 1 - self.L, -1, -1): v = v + Us[i] v = torch.cat((v, Ud[i]), -1) v = self.evenOdd(v) v = self.out(v[:, :N, :, :].contiguous().view(B, N, -1)) return (v.contiguous(), None) def wavelet_transform(self, x): xa = torch.cat([x[:, ::2, :, :], x[:, 1::2, :, :], ], -1) d = torch.matmul(xa, self.ec_d) s = torch.matmul(xa, self.ec_s) return d, s def evenOdd(self, x): B, N, c, ich = x.shape # (B, N, c, k) assert ich == 2 * self.k x_e = torch.matmul(x, self.rc_e) x_o = torch.matmul(x, self.rc_o) x = torch.zeros(B, N * 2, c, self.k, device=x.device) x[..., ::2, :, :] = x_e x[..., 1::2, :, :] = x_o return x class FourierCrossAttentionW(nn.Module): def __init__(self, in_channels, out_channels, seq_len_q, seq_len_kv, modes=16, activation='tanh', mode_select_method='random'): super(FourierCrossAttentionW, self).__init__() print('corss fourier correlation used!') self.in_channels = in_channels self.out_channels = out_channels self.modes1 = modes self.activation = activation def compl_mul1d(self, order, x, weights): x_flag = True w_flag = True if not torch.is_complex(x): x_flag = False x = torch.complex(x, torch.zeros_like(x).to(x.device)) if not torch.is_complex(weights): w_flag = False weights = torch.complex(weights, torch.zeros_like(weights).to(weights.device)) if x_flag or w_flag: return torch.complex(torch.einsum(order, x.real, weights.real) - torch.einsum(order, x.imag, weights.imag), torch.einsum(order, x.real, weights.imag) + torch.einsum(order, x.imag, weights.real)) else: return torch.einsum(order, x.real, weights.real) def forward(self, q, k, v, mask): B, L, E, H = q.shape xq = q.permute(0, 3, 2, 1) # size = [B, H, E, L] torch.Size([3, 8, 64, 512]) xk = k.permute(0, 3, 2, 1) xv = v.permute(0, 3, 2, 1) self.index_q = list(range(0, min(int(L // 2), self.modes1))) self.index_k_v = list(range(0, min(int(xv.shape[3] // 2), self.modes1))) # Compute Fourier coefficients xq_ft_ = torch.zeros(B, H, E, len(self.index_q), device=xq.device, dtype=torch.cfloat) xq_ft = torch.fft.rfft(xq, dim=-1) for i, j in enumerate(self.index_q): xq_ft_[:, :, :, i] = xq_ft[:, :, :, j] xk_ft_ = torch.zeros(B, H, E, len(self.index_k_v), device=xq.device, dtype=torch.cfloat) xk_ft = torch.fft.rfft(xk, dim=-1) for i, j in enumerate(self.index_k_v): xk_ft_[:, :, :, i] = xk_ft[:, :, :, j] xqk_ft = (self.compl_mul1d("bhex,bhey->bhxy", xq_ft_, xk_ft_)) if self.activation == 'tanh': xqk_ft = torch.complex(xqk_ft.real.tanh(), xqk_ft.imag.tanh()) elif self.activation == 'softmax': xqk_ft = torch.softmax(abs(xqk_ft), dim=-1) xqk_ft = torch.complex(xqk_ft, torch.zeros_like(xqk_ft)) else: raise Exception('{} actiation function is not implemented'.format(self.activation)) xqkv_ft = self.compl_mul1d("bhxy,bhey->bhex", xqk_ft, xk_ft_) xqkvw = xqkv_ft out_ft = torch.zeros(B, H, E, L // 2 + 1, device=xq.device, dtype=torch.cfloat) for i, j in enumerate(self.index_q): out_ft[:, :, :, j] = xqkvw[:, :, :, i] out = torch.fft.irfft(out_ft / self.in_channels / self.out_channels, n=xq.size(-1)).permute(0, 3, 2, 1) # size = [B, L, H, E] return (out, None) class sparseKernelFT1d(nn.Module): def __init__(self, k, alpha, c=1, nl=1, initializer=None, **kwargs): super(sparseKernelFT1d, self).__init__() self.modes1 = alpha self.scale = (1 / (c * k * c * k)) self.weights1 = nn.Parameter(self.scale * torch.rand(c * k, c * k, self.modes1, dtype=torch.float)) self.weights2 = nn.Parameter(self.scale * torch.rand(c * k, c * k, self.modes1, dtype=torch.float)) self.weights1.requires_grad = True self.weights2.requires_grad = True self.k = k def compl_mul1d(self, order, x, weights): x_flag = True w_flag = True if not torch.is_complex(x): x_flag = False x = torch.complex(x, torch.zeros_like(x).to(x.device)) if not torch.is_complex(weights): w_flag = False weights = torch.complex(weights, torch.zeros_like(weights).to(weights.device)) if x_flag or w_flag: return torch.complex(torch.einsum(order, x.real, weights.real) - torch.einsum(order, x.imag, weights.imag), torch.einsum(order, x.real, weights.imag) + torch.einsum(order, x.imag, weights.real)) else: return torch.einsum(order, x.real, weights.real) def forward(self, x): B, N, c, k = x.shape # (B, N, c, k) x = x.view(B, N, -1) x = x.permute(0, 2, 1) x_fft = torch.fft.rfft(x) # Multiply relevant Fourier modes l = min(self.modes1, N // 2 + 1) out_ft = torch.zeros(B, c * k, N // 2 + 1, device=x.device, dtype=torch.cfloat) out_ft[:, :, :l] = self.compl_mul1d("bix,iox->box", x_fft[:, :, :l], torch.complex(self.weights1, self.weights2)[:, :, :l]) x = torch.fft.irfft(out_ft, n=N) x = x.permute(0, 2, 1).view(B, N, c, k) return x # ## class MWT_CZ1d(nn.Module): def __init__(self, k=3, alpha=64, L=0, c=1, base='legendre', initializer=None, **kwargs): super(MWT_CZ1d, self).__init__() self.k = k self.L = L H0, H1, G0, G1, PHI0, PHI1 = get_filter(base, k) H0r = H0 @ PHI0 G0r = G0 @ PHI0 H1r = H1 @ PHI1 G1r = G1 @ PHI1 H0r[np.abs(H0r) < 1e-8] = 0 H1r[np.abs(H1r) < 1e-8] = 0 G0r[np.abs(G0r) < 1e-8] = 0 G1r[np.abs(G1r) < 1e-8] = 0 self.max_item = 3 self.A = sparseKernelFT1d(k, alpha, c) self.B = sparseKernelFT1d(k, alpha, c) self.C = sparseKernelFT1d(k, alpha, c) self.T0 = nn.Linear(k, k) self.register_buffer('ec_s', torch.Tensor( np.concatenate((H0.T, H1.T), axis=0))) self.register_buffer('ec_d', torch.Tensor( np.concatenate((G0.T, G1.T), axis=0))) self.register_buffer('rc_e', torch.Tensor( np.concatenate((H0r, G0r), axis=0))) self.register_buffer('rc_o', torch.Tensor( np.concatenate((H1r, G1r), axis=0))) def forward(self, x): B, N, c, k = x.shape # (B, N, k) ns = math.floor(np.log2(N)) nl = pow(2, math.ceil(np.log2(N))) extra_x = x[:, 0:nl - N, :, :] x = torch.cat([x, extra_x], 1) Ud = torch.jit.annotate(List[Tensor], []) Us = torch.jit.annotate(List[Tensor], []) for i in range(ns - self.L): d, x = self.wavelet_transform(x) Ud += [self.A(d) + self.B(x)] Us += [self.C(d)] x = self.T0(x) # coarsest scale transform # reconstruct for i in range(ns - 1 - self.L, -1, -1): x = x + Us[i] x = torch.cat((x, Ud[i]), -1) x = self.evenOdd(x) x = x[:, :N, :, :] return x def wavelet_transform(self, x): xa = torch.cat([x[:, ::2, :, :], x[:, 1::2, :, :], ], -1) d = torch.matmul(xa, self.ec_d) s = torch.matmul(xa, self.ec_s) return d, s def evenOdd(self, x): B, N, c, ich = x.shape # (B, N, c, k) assert ich == 2 * self.k x_e = torch.matmul(x, self.rc_e) x_o = torch.matmul(x, self.rc_o) x = torch.zeros(B, N * 2, c, self.k, device=x.device) x[..., ::2, :, :] = x_e x[..., 1::2, :, :] = x_o return x library/layers/Pyraformer_EncDec.py000066400000000000000000000164111443355502200177300ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F from torch.nn.modules.linear import Linear from layers.SelfAttention_Family import AttentionLayer, FullAttention from layers.Embed import DataEmbedding import math def get_mask(input_size, window_size, inner_size): """Get the attention mask of PAM-Naive""" # Get the size of all layers all_size = [] all_size.append(input_size) for i in range(len(window_size)): layer_size = math.floor(all_size[i] / window_size[i]) all_size.append(layer_size) seq_length = sum(all_size) mask = torch.zeros(seq_length, seq_length) # get intra-scale mask inner_window = inner_size // 2 for layer_idx in range(len(all_size)): start = sum(all_size[:layer_idx]) for i in range(start, start + all_size[layer_idx]): left_side = max(i - inner_window, start) right_side = min(i + inner_window + 1, start + all_size[layer_idx]) mask[i, left_side:right_side] = 1 # get inter-scale mask for layer_idx in range(1, len(all_size)): start = sum(all_size[:layer_idx]) for i in range(start, start + all_size[layer_idx]): left_side = (start - all_size[layer_idx - 1]) + \ (i - start) * window_size[layer_idx - 1] if i == (start + all_size[layer_idx] - 1): right_side = start else: right_side = ( start - all_size[layer_idx - 1]) + (i - start + 1) * window_size[layer_idx - 1] mask[i, left_side:right_side] = 1 mask[left_side:right_side, i] = 1 mask = (1 - mask).bool() return mask, all_size def refer_points(all_sizes, window_size): """Gather features from PAM's pyramid sequences""" input_size = all_sizes[0] indexes = torch.zeros(input_size, len(all_sizes)) for i in range(input_size): indexes[i][0] = i former_index = i for j in range(1, len(all_sizes)): start = sum(all_sizes[:j]) inner_layer_idx = former_index - (start - all_sizes[j - 1]) former_index = start + \ min(inner_layer_idx // window_size[j - 1], all_sizes[j] - 1) indexes[i][j] = former_index indexes = indexes.unsqueeze(0).unsqueeze(3) return indexes.long() class RegularMask(): def __init__(self, mask): self._mask = mask.unsqueeze(1) @property def mask(self): return self._mask class EncoderLayer(nn.Module): """ Compose with two layers """ def __init__(self, d_model, d_inner, n_head, dropout=0.1, normalize_before=True): super(EncoderLayer, self).__init__() self.slf_attn = AttentionLayer( FullAttention(mask_flag=True, factor=0, attention_dropout=dropout, output_attention=False), d_model, n_head) self.pos_ffn = PositionwiseFeedForward( d_model, d_inner, dropout=dropout, normalize_before=normalize_before) def forward(self, enc_input, slf_attn_mask=None): attn_mask = RegularMask(slf_attn_mask) enc_output, _ = self.slf_attn( enc_input, enc_input, enc_input, attn_mask=attn_mask) enc_output = self.pos_ffn(enc_output) return enc_output class Encoder(nn.Module): """ A encoder model with self attention mechanism. """ def __init__(self, configs, window_size, inner_size): super().__init__() d_bottleneck = configs.d_model//4 self.mask, self.all_size = get_mask( configs.seq_len, window_size, inner_size) self.indexes = refer_points(self.all_size, window_size) self.layers = nn.ModuleList([ EncoderLayer(configs.d_model, configs.d_ff, configs.n_heads, dropout=configs.dropout, normalize_before=False) for _ in range(configs.e_layers) ]) # naive pyramid attention self.enc_embedding = DataEmbedding( configs.enc_in, configs.d_model, configs.dropout) self.conv_layers = Bottleneck_Construct( configs.d_model, window_size, d_bottleneck) def forward(self, x_enc, x_mark_enc): seq_enc = self.enc_embedding(x_enc, x_mark_enc) mask = self.mask.repeat(len(seq_enc), 1, 1).to(x_enc.device) seq_enc = self.conv_layers(seq_enc) for i in range(len(self.layers)): seq_enc = self.layers[i](seq_enc, mask) indexes = self.indexes.repeat(seq_enc.size( 0), 1, 1, seq_enc.size(2)).to(seq_enc.device) indexes = indexes.view(seq_enc.size(0), -1, seq_enc.size(2)) all_enc = torch.gather(seq_enc, 1, indexes) seq_enc = all_enc.view(seq_enc.size(0), self.all_size[0], -1) return seq_enc class ConvLayer(nn.Module): def __init__(self, c_in, window_size): super(ConvLayer, self).__init__() self.downConv = nn.Conv1d(in_channels=c_in, out_channels=c_in, kernel_size=window_size, stride=window_size) self.norm = nn.BatchNorm1d(c_in) self.activation = nn.ELU() def forward(self, x): x = self.downConv(x) x = self.norm(x) x = self.activation(x) return x class Bottleneck_Construct(nn.Module): """Bottleneck convolution CSCM""" def __init__(self, d_model, window_size, d_inner): super(Bottleneck_Construct, self).__init__() if not isinstance(window_size, list): self.conv_layers = nn.ModuleList([ ConvLayer(d_inner, window_size), ConvLayer(d_inner, window_size), ConvLayer(d_inner, window_size) ]) else: self.conv_layers = [] for i in range(len(window_size)): self.conv_layers.append(ConvLayer(d_inner, window_size[i])) self.conv_layers = nn.ModuleList(self.conv_layers) self.up = Linear(d_inner, d_model) self.down = Linear(d_model, d_inner) self.norm = nn.LayerNorm(d_model) def forward(self, enc_input): temp_input = self.down(enc_input).permute(0, 2, 1) all_inputs = [] for i in range(len(self.conv_layers)): temp_input = self.conv_layers[i](temp_input) all_inputs.append(temp_input) all_inputs = torch.cat(all_inputs, dim=2).transpose(1, 2) all_inputs = self.up(all_inputs) all_inputs = torch.cat([enc_input, all_inputs], dim=1) all_inputs = self.norm(all_inputs) return all_inputs class PositionwiseFeedForward(nn.Module): """ Two-layer position-wise feed-forward neural network. """ def __init__(self, d_in, d_hid, dropout=0.1, normalize_before=True): super().__init__() self.normalize_before = normalize_before self.w_1 = nn.Linear(d_in, d_hid) self.w_2 = nn.Linear(d_hid, d_in) self.layer_norm = nn.LayerNorm(d_in, eps=1e-6) self.dropout = nn.Dropout(dropout) def forward(self, x): residual = x if self.normalize_before: x = self.layer_norm(x) x = F.gelu(self.w_1(x)) x = self.dropout(x) x = self.w_2(x) x = self.dropout(x) x = x + residual if not self.normalize_before: x = self.layer_norm(x) return x library/layers/SelfAttention_Family.py000066400000000000000000000274451443355502200204720ustar00rootroot00000000000000import torch import torch.nn as nn import numpy as np from math import sqrt from utils.masking import TriangularCausalMask, ProbMask from reformer_pytorch import LSHSelfAttention from einops import rearrange, repeat class DSAttention(nn.Module): '''De-stationary Attention''' def __init__(self, mask_flag=True, factor=5, scale=None, attention_dropout=0.1, output_attention=False): super(DSAttention, self).__init__() self.scale = scale self.mask_flag = mask_flag self.output_attention = output_attention self.dropout = nn.Dropout(attention_dropout) def forward(self, queries, keys, values, attn_mask, tau=None, delta=None): B, L, H, E = queries.shape _, S, _, D = values.shape scale = self.scale or 1. / sqrt(E) tau = 1.0 if tau is None else tau.unsqueeze( 1).unsqueeze(1) # B x 1 x 1 x 1 delta = 0.0 if delta is None else delta.unsqueeze( 1).unsqueeze(1) # B x 1 x 1 x S # De-stationary Attention, rescaling pre-softmax score with learned de-stationary factors scores = torch.einsum("blhe,bshe->bhls", queries, keys) * tau + delta if self.mask_flag: if attn_mask is None: attn_mask = TriangularCausalMask(B, L, device=queries.device) scores.masked_fill_(attn_mask.mask, -np.inf) A = self.dropout(torch.softmax(scale * scores, dim=-1)) V = torch.einsum("bhls,bshd->blhd", A, values) if self.output_attention: return (V.contiguous(), A) else: return (V.contiguous(), None) class FullAttention(nn.Module): def __init__(self, mask_flag=True, factor=5, scale=None, attention_dropout=0.1, output_attention=False): super(FullAttention, self).__init__() self.scale = scale self.mask_flag = mask_flag self.output_attention = output_attention self.dropout = nn.Dropout(attention_dropout) def forward(self, queries, keys, values, attn_mask, tau=None, delta=None): B, L, H, E = queries.shape _, S, _, D = values.shape scale = self.scale or 1. / sqrt(E) scores = torch.einsum("blhe,bshe->bhls", queries, keys) if self.mask_flag: if attn_mask is None: attn_mask = TriangularCausalMask(B, L, device=queries.device) scores.masked_fill_(attn_mask.mask, -np.inf) A = self.dropout(torch.softmax(scale * scores, dim=-1)) V = torch.einsum("bhls,bshd->blhd", A, values) if self.output_attention: return (V.contiguous(), A) else: return (V.contiguous(), None) class ProbAttention(nn.Module): def __init__(self, mask_flag=True, factor=5, scale=None, attention_dropout=0.1, output_attention=False): super(ProbAttention, self).__init__() self.factor = factor self.scale = scale self.mask_flag = mask_flag self.output_attention = output_attention self.dropout = nn.Dropout(attention_dropout) def _prob_QK(self, Q, K, sample_k, n_top): # n_top: c*ln(L_q) # Q [B, H, L, D] B, H, L_K, E = K.shape _, _, L_Q, _ = Q.shape # calculate the sampled Q_K K_expand = K.unsqueeze(-3).expand(B, H, L_Q, L_K, E) # real U = U_part(factor*ln(L_k))*L_q index_sample = torch.randint(L_K, (L_Q, sample_k)) K_sample = K_expand[:, :, torch.arange( L_Q).unsqueeze(1), index_sample, :] Q_K_sample = torch.matmul( Q.unsqueeze(-2), K_sample.transpose(-2, -1)).squeeze() # find the Top_k query with sparisty measurement M = Q_K_sample.max(-1)[0] - torch.div(Q_K_sample.sum(-1), L_K) M_top = M.topk(n_top, sorted=False)[1] # use the reduced Q to calculate Q_K Q_reduce = Q[torch.arange(B)[:, None, None], torch.arange(H)[None, :, None], M_top, :] # factor*ln(L_q) Q_K = torch.matmul(Q_reduce, K.transpose(-2, -1)) # factor*ln(L_q)*L_k return Q_K, M_top def _get_initial_context(self, V, L_Q): B, H, L_V, D = V.shape if not self.mask_flag: # V_sum = V.sum(dim=-2) V_sum = V.mean(dim=-2) contex = V_sum.unsqueeze(-2).expand(B, H, L_Q, V_sum.shape[-1]).clone() else: # use mask # requires that L_Q == L_V, i.e. for self-attention only assert (L_Q == L_V) contex = V.cumsum(dim=-2) return contex def _update_context(self, context_in, V, scores, index, L_Q, attn_mask): B, H, L_V, D = V.shape if self.mask_flag: attn_mask = ProbMask(B, H, L_Q, index, scores, device=V.device) scores.masked_fill_(attn_mask.mask, -np.inf) attn = torch.softmax(scores, dim=-1) # nn.Softmax(dim=-1)(scores) context_in[torch.arange(B)[:, None, None], torch.arange(H)[None, :, None], index, :] = torch.matmul(attn, V).type_as(context_in) if self.output_attention: attns = (torch.ones([B, H, L_V, L_V]) / L_V).type_as(attn).to(attn.device) attns[torch.arange(B)[:, None, None], torch.arange(H)[ None, :, None], index, :] = attn return (context_in, attns) else: return (context_in, None) def forward(self, queries, keys, values, attn_mask, tau=None, delta=None): B, L_Q, H, D = queries.shape _, L_K, _, _ = keys.shape queries = queries.transpose(2, 1) keys = keys.transpose(2, 1) values = values.transpose(2, 1) U_part = self.factor * \ np.ceil(np.log(L_K)).astype('int').item() # c*ln(L_k) u = self.factor * \ np.ceil(np.log(L_Q)).astype('int').item() # c*ln(L_q) U_part = U_part if U_part < L_K else L_K u = u if u < L_Q else L_Q scores_top, index = self._prob_QK( queries, keys, sample_k=U_part, n_top=u) # add scale factor scale = self.scale or 1. / sqrt(D) if scale is not None: scores_top = scores_top * scale # get the context context = self._get_initial_context(values, L_Q) # update the context with selected top_k queries context, attn = self._update_context( context, values, scores_top, index, L_Q, attn_mask) return context.contiguous(), attn class AttentionLayer(nn.Module): def __init__(self, attention, d_model, n_heads, d_keys=None, d_values=None): super(AttentionLayer, self).__init__() d_keys = d_keys or (d_model // n_heads) d_values = d_values or (d_model // n_heads) self.inner_attention = attention self.query_projection = nn.Linear(d_model, d_keys * n_heads) self.key_projection = nn.Linear(d_model, d_keys * n_heads) self.value_projection = nn.Linear(d_model, d_values * n_heads) self.out_projection = nn.Linear(d_values * n_heads, d_model) self.n_heads = n_heads def forward(self, queries, keys, values, attn_mask, tau=None, delta=None): B, L, _ = queries.shape _, S, _ = keys.shape H = self.n_heads queries = self.query_projection(queries).view(B, L, H, -1) keys = self.key_projection(keys).view(B, S, H, -1) values = self.value_projection(values).view(B, S, H, -1) out, attn = self.inner_attention( queries, keys, values, attn_mask, tau=tau, delta=delta ) out = out.view(B, L, -1) return self.out_projection(out), attn class ReformerLayer(nn.Module): def __init__(self, attention, d_model, n_heads, d_keys=None, d_values=None, causal=False, bucket_size=4, n_hashes=4): super().__init__() self.bucket_size = bucket_size self.attn = LSHSelfAttention( dim=d_model, heads=n_heads, bucket_size=bucket_size, n_hashes=n_hashes, causal=causal ) def fit_length(self, queries): # inside reformer: assert N % (bucket_size * 2) == 0 B, N, C = queries.shape if N % (self.bucket_size * 2) == 0: return queries else: # fill the time series fill_len = (self.bucket_size * 2) - (N % (self.bucket_size * 2)) return torch.cat([queries, torch.zeros([B, fill_len, C]).to(queries.device)], dim=1) def forward(self, queries, keys, values, attn_mask, tau, delta): # in Reformer: defalut queries=keys B, N, C = queries.shape queries = self.attn(self.fit_length(queries))[:, :N, :] return queries, None class TwoStageAttentionLayer(nn.Module): ''' The Two Stage Attention (TSA) Layer input/output shape: [batch_size, Data_dim(D), Seg_num(L), d_model] ''' def __init__(self, configs, seg_num, factor, d_model, n_heads, d_ff=None, dropout=0.1): super(TwoStageAttentionLayer, self).__init__() d_ff = d_ff or 4 * d_model self.time_attention = AttentionLayer(FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=configs.output_attention), d_model, n_heads) self.dim_sender = AttentionLayer(FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=configs.output_attention), d_model, n_heads) self.dim_receiver = AttentionLayer(FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=configs.output_attention), d_model, n_heads) self.router = nn.Parameter(torch.randn(seg_num, factor, d_model)) self.dropout = nn.Dropout(dropout) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.norm3 = nn.LayerNorm(d_model) self.norm4 = nn.LayerNorm(d_model) self.MLP1 = nn.Sequential(nn.Linear(d_model, d_ff), nn.GELU(), nn.Linear(d_ff, d_model)) self.MLP2 = nn.Sequential(nn.Linear(d_model, d_ff), nn.GELU(), nn.Linear(d_ff, d_model)) def forward(self, x, attn_mask=None, tau=None, delta=None): # Cross Time Stage: Directly apply MSA to each dimension batch = x.shape[0] time_in = rearrange(x, 'b ts_d seg_num d_model -> (b ts_d) seg_num d_model') time_enc, attn = self.time_attention( time_in, time_in, time_in, attn_mask=None, tau=None, delta=None ) dim_in = time_in + self.dropout(time_enc) dim_in = self.norm1(dim_in) dim_in = dim_in + self.dropout(self.MLP1(dim_in)) dim_in = self.norm2(dim_in) # Cross Dimension Stage: use a small set of learnable vectors to aggregate and distribute messages to build the D-to-D connection dim_send = rearrange(dim_in, '(b ts_d) seg_num d_model -> (b seg_num) ts_d d_model', b=batch) batch_router = repeat(self.router, 'seg_num factor d_model -> (repeat seg_num) factor d_model', repeat=batch) dim_buffer, attn = self.dim_sender(batch_router, dim_send, dim_send, attn_mask=None, tau=None, delta=None) dim_receive, attn = self.dim_receiver(dim_send, dim_buffer, dim_buffer, attn_mask=None, tau=None, delta=None) dim_enc = dim_send + self.dropout(dim_receive) dim_enc = self.norm3(dim_enc) dim_enc = dim_enc + self.dropout(self.MLP2(dim_enc)) dim_enc = self.norm4(dim_enc) final_out = rearrange(dim_enc, '(b seg_num) ts_d d_model -> b ts_d seg_num d_model', b=batch) return final_outlibrary/layers/Transformer_EncDec.py000066400000000000000000000115011443355502200200770ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F class ConvLayer(nn.Module): def __init__(self, c_in): super(ConvLayer, self).__init__() self.downConv = nn.Conv1d(in_channels=c_in, out_channels=c_in, kernel_size=3, padding=2, padding_mode='circular') self.norm = nn.BatchNorm1d(c_in) self.activation = nn.ELU() self.maxPool = nn.MaxPool1d(kernel_size=3, stride=2, padding=1) def forward(self, x): x = self.downConv(x.permute(0, 2, 1)) x = self.norm(x) x = self.activation(x) x = self.maxPool(x) x = x.transpose(1, 2) return x class EncoderLayer(nn.Module): def __init__(self, attention, d_model, d_ff=None, dropout=0.1, activation="relu"): super(EncoderLayer, self).__init__() d_ff = d_ff or 4 * d_model self.attention = attention self.conv1 = nn.Conv1d(in_channels=d_model, out_channels=d_ff, kernel_size=1) self.conv2 = nn.Conv1d(in_channels=d_ff, out_channels=d_model, kernel_size=1) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) self.activation = F.relu if activation == "relu" else F.gelu def forward(self, x, attn_mask=None, tau=None, delta=None): new_x, attn = self.attention( x, x, x, attn_mask=attn_mask, tau=tau, delta=delta ) x = x + self.dropout(new_x) y = x = self.norm1(x) y = self.dropout(self.activation(self.conv1(y.transpose(-1, 1)))) y = self.dropout(self.conv2(y).transpose(-1, 1)) return self.norm2(x + y), attn class Encoder(nn.Module): def __init__(self, attn_layers, conv_layers=None, norm_layer=None): super(Encoder, self).__init__() self.attn_layers = nn.ModuleList(attn_layers) self.conv_layers = nn.ModuleList(conv_layers) if conv_layers is not None else None self.norm = norm_layer def forward(self, x, attn_mask=None, tau=None, delta=None): # x [B, L, D] attns = [] if self.conv_layers is not None: for i, (attn_layer, conv_layer) in enumerate(zip(self.attn_layers, self.conv_layers)): delta = delta if i == 0 else None x, attn = attn_layer(x, attn_mask=attn_mask, tau=tau, delta=delta) x = conv_layer(x) attns.append(attn) x, attn = self.attn_layers[-1](x, tau=tau, delta=None) attns.append(attn) else: for attn_layer in self.attn_layers: x, attn = attn_layer(x, attn_mask=attn_mask, tau=tau, delta=delta) attns.append(attn) if self.norm is not None: x = self.norm(x) return x, attns class DecoderLayer(nn.Module): def __init__(self, self_attention, cross_attention, d_model, d_ff=None, dropout=0.1, activation="relu"): super(DecoderLayer, self).__init__() d_ff = d_ff or 4 * d_model self.self_attention = self_attention self.cross_attention = cross_attention self.conv1 = nn.Conv1d(in_channels=d_model, out_channels=d_ff, kernel_size=1) self.conv2 = nn.Conv1d(in_channels=d_ff, out_channels=d_model, kernel_size=1) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.norm3 = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) self.activation = F.relu if activation == "relu" else F.gelu def forward(self, x, cross, x_mask=None, cross_mask=None, tau=None, delta=None): x = x + self.dropout(self.self_attention( x, x, x, attn_mask=x_mask, tau=tau, delta=None )[0]) x = self.norm1(x) x = x + self.dropout(self.cross_attention( x, cross, cross, attn_mask=cross_mask, tau=tau, delta=delta )[0]) y = x = self.norm2(x) y = self.dropout(self.activation(self.conv1(y.transpose(-1, 1)))) y = self.dropout(self.conv2(y).transpose(-1, 1)) return self.norm3(x + y) class Decoder(nn.Module): def __init__(self, layers, norm_layer=None, projection=None): super(Decoder, self).__init__() self.layers = nn.ModuleList(layers) self.norm = norm_layer self.projection = projection def forward(self, x, cross, x_mask=None, cross_mask=None, tau=None, delta=None): for layer in self.layers: x = layer(x, cross, x_mask=x_mask, cross_mask=cross_mask, tau=tau, delta=delta) if self.norm is not None: x = self.norm(x) if self.projection is not None: x = self.projection(x) return x library/layers/__init__.py000066400000000000000000000000001443355502200161230ustar00rootroot00000000000000library/models/000077500000000000000000000000001443355502200140105ustar00rootroot00000000000000library/models/Autoformer.py000066400000000000000000000153531443355502200165140ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F from layers.Embed import DataEmbedding, DataEmbedding_wo_pos from layers.AutoCorrelation import AutoCorrelation, AutoCorrelationLayer from layers.Autoformer_EncDec import Encoder, Decoder, EncoderLayer, DecoderLayer, my_Layernorm, series_decomp import math import numpy as np class Model(nn.Module): """ Autoformer is the first method to achieve the series-wise connection, with inherent O(LlogL) complexity Paper link: https://openreview.net/pdf?id=I55UqU-M11y """ def __init__(self, configs): super(Model, self).__init__() self.task_name = configs.task_name self.seq_len = configs.seq_len self.label_len = configs.label_len self.pred_len = configs.pred_len self.output_attention = configs.output_attention # Decomp kernel_size = configs.moving_avg self.decomp = series_decomp(kernel_size) # Embedding self.enc_embedding = DataEmbedding_wo_pos(configs.enc_in, configs.d_model, configs.embed, configs.freq, configs.dropout) # Encoder self.encoder = Encoder( [ EncoderLayer( AutoCorrelationLayer( AutoCorrelation(False, configs.factor, attention_dropout=configs.dropout, output_attention=configs.output_attention), configs.d_model, configs.n_heads), configs.d_model, configs.d_ff, moving_avg=configs.moving_avg, dropout=configs.dropout, activation=configs.activation ) for l in range(configs.e_layers) ], norm_layer=my_Layernorm(configs.d_model) ) # Decoder if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': self.dec_embedding = DataEmbedding_wo_pos(configs.dec_in, configs.d_model, configs.embed, configs.freq, configs.dropout) self.decoder = Decoder( [ DecoderLayer( AutoCorrelationLayer( AutoCorrelation(True, configs.factor, attention_dropout=configs.dropout, output_attention=False), configs.d_model, configs.n_heads), AutoCorrelationLayer( AutoCorrelation(False, configs.factor, attention_dropout=configs.dropout, output_attention=False), configs.d_model, configs.n_heads), configs.d_model, configs.c_out, configs.d_ff, moving_avg=configs.moving_avg, dropout=configs.dropout, activation=configs.activation, ) for l in range(configs.d_layers) ], norm_layer=my_Layernorm(configs.d_model), projection=nn.Linear(configs.d_model, configs.c_out, bias=True) ) if self.task_name == 'imputation': self.projection = nn.Linear( configs.d_model, configs.c_out, bias=True) if self.task_name == 'anomaly_detection': self.projection = nn.Linear( configs.d_model, configs.c_out, bias=True) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear( configs.d_model * configs.seq_len, configs.num_class) def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # decomp init mean = torch.mean(x_enc, dim=1).unsqueeze( 1).repeat(1, self.pred_len, 1) zeros = torch.zeros([x_dec.shape[0], self.pred_len, x_dec.shape[2]], device=x_enc.device) seasonal_init, trend_init = self.decomp(x_enc) # decoder input trend_init = torch.cat( [trend_init[:, -self.label_len:, :], mean], dim=1) seasonal_init = torch.cat( [seasonal_init[:, -self.label_len:, :], zeros], dim=1) # enc enc_out = self.enc_embedding(x_enc, x_mark_enc) enc_out, attns = self.encoder(enc_out, attn_mask=None) # dec dec_out = self.dec_embedding(seasonal_init, x_mark_dec) seasonal_part, trend_part = self.decoder(dec_out, enc_out, x_mask=None, cross_mask=None, trend=trend_init) # final dec_out = trend_part + seasonal_part return dec_out def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): # enc enc_out = self.enc_embedding(x_enc, x_mark_enc) enc_out, attns = self.encoder(enc_out, attn_mask=None) # final dec_out = self.projection(enc_out) return dec_out def anomaly_detection(self, x_enc): # enc enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None) # final dec_out = self.projection(enc_out) return dec_out def classification(self, x_enc, x_mark_enc): # enc enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None) # Output # the output transformer encoder/decoder embeddings don't include non-linearity output = self.act(enc_out) output = self.dropout(output) # zero-out padding embeddings output = output * x_mark_enc.unsqueeze(-1) # (batch_size, seq_length * d_model) output = output.reshape(output.shape[0], -1) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation( x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/Crossformer.py000066400000000000000000000143331443355502200166720ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F from einops import rearrange, repeat from layers.Crossformer_EncDec import scale_block, Encoder, Decoder, DecoderLayer from layers.Embed import PatchEmbedding from layers.SelfAttention_Family import AttentionLayer, FullAttention, TwoStageAttentionLayer from models.PatchTST import FlattenHead from math import ceil class Model(nn.Module): """ Paper link: https://openreview.net/pdf?id=vSVLM2j9eie """ def __init__(self, configs): super(Model, self).__init__() self.enc_in = configs.enc_in self.seq_len = configs.seq_len self.pred_len = configs.pred_len self.seg_len = 12 self.win_size = 2 self.task_name = configs.task_name # The padding operation to handle invisible sgemnet length self.pad_in_len = ceil(1.0 * configs.seq_len / self.seg_len) * self.seg_len self.pad_out_len = ceil(1.0 * configs.pred_len / self.seg_len) * self.seg_len self.in_seg_num = self.pad_in_len // self.seg_len self.out_seg_num = ceil(self.in_seg_num / (self.win_size ** (configs.e_layers - 1))) self.head_nf = configs.d_model * self.out_seg_num # Embedding self.enc_value_embedding = PatchEmbedding(configs.d_model, self.seg_len, self.seg_len, self.pad_in_len - configs.seq_len, 0) self.enc_pos_embedding = nn.Parameter( torch.randn(1, configs.enc_in, self.in_seg_num, configs.d_model)) self.pre_norm = nn.LayerNorm(configs.d_model) # Encoder self.encoder = Encoder( [ scale_block(configs, 1 if l is 0 else self.win_size, configs.d_model, configs.n_heads, configs.d_ff, 1, configs.dropout, self.in_seg_num if l is 0 else ceil(self.in_seg_num / self.win_size ** l), configs.factor ) for l in range(configs.e_layers) ] ) # Decoder self.dec_pos_embedding = nn.Parameter( torch.randn(1, configs.enc_in, (self.pad_out_len // self.seg_len), configs.d_model)) self.decoder = Decoder( [ DecoderLayer( TwoStageAttentionLayer(configs, (self.pad_out_len // self.seg_len), configs.factor, configs.d_model, configs.n_heads, configs.d_ff, configs.dropout), AttentionLayer( FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False), configs.d_model, configs.n_heads), self.seg_len, configs.d_model, configs.d_ff, dropout=configs.dropout, # activation=configs.activation, ) for l in range(configs.e_layers + 1) ], ) if self.task_name == 'imputation' or self.task_name == 'anomaly_detection': self.head = FlattenHead(configs.enc_in, self.head_nf, configs.seq_len, head_dropout=configs.dropout) elif self.task_name == 'classification': self.flatten = nn.Flatten(start_dim=-2) self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear( self.head_nf * configs.enc_in, configs.num_class) def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # embedding x_enc, n_vars = self.enc_value_embedding(x_enc.permute(0, 2, 1)) x_enc = rearrange(x_enc, '(b d) seg_num d_model -> b d seg_num d_model', d = n_vars) x_enc += self.enc_pos_embedding x_enc = self.pre_norm(x_enc) enc_out, attns = self.encoder(x_enc) dec_in = repeat(self.dec_pos_embedding, 'b ts_d l d -> (repeat b) ts_d l d', repeat=x_enc.shape[0]) dec_out = self.decoder(dec_in, enc_out) return dec_out def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): # embedding x_enc, n_vars = self.enc_value_embedding(x_enc.permute(0, 2, 1)) x_enc = rearrange(x_enc, '(b d) seg_num d_model -> b d seg_num d_model', d=n_vars) x_enc += self.enc_pos_embedding x_enc = self.pre_norm(x_enc) enc_out, attns = self.encoder(x_enc) dec_out = self.head(enc_out[-1].permute(0, 1, 3, 2)).permute(0, 2, 1) return dec_out def anomaly_detection(self, x_enc): # embedding x_enc, n_vars = self.enc_value_embedding(x_enc.permute(0, 2, 1)) x_enc = rearrange(x_enc, '(b d) seg_num d_model -> b d seg_num d_model', d=n_vars) x_enc += self.enc_pos_embedding x_enc = self.pre_norm(x_enc) enc_out, attns = self.encoder(x_enc) dec_out = self.head(enc_out[-1].permute(0, 1, 3, 2)).permute(0, 2, 1) return dec_out def classification(self, x_enc, x_mark_enc): # embedding x_enc, n_vars = self.enc_value_embedding(x_enc.permute(0, 2, 1)) x_enc = rearrange(x_enc, '(b d) seg_num d_model -> b d seg_num d_model', d=n_vars) x_enc += self.enc_pos_embedding x_enc = self.pre_norm(x_enc) enc_out, attns = self.encoder(x_enc) # Output from Non-stationary Transformer output = self.flatten(enc_out[-1].permute(0, 1, 3, 2)) output = self.dropout(output) output = output.reshape(output.shape[0], -1) output = self.projection(output) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return Nonelibrary/models/DLinear.py000066400000000000000000000107521443355502200157050ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F from layers.Autoformer_EncDec import series_decomp class Model(nn.Module): """ Paper link: https://arxiv.org/pdf/2205.13504.pdf """ def __init__(self, configs, individual=False): """ individual: Bool, whether shared model among different variates. """ super(Model, self).__init__() self.task_name = configs.task_name self.seq_len = configs.seq_len if self.task_name == 'classification' or self.task_name == 'anomaly_detection' or self.task_name == 'imputation': self.pred_len = configs.seq_len else: self.pred_len = configs.pred_len # Series decomposition block from Autoformer self.decompsition = series_decomp(configs.moving_avg) self.individual = individual self.channels = configs.enc_in if self.individual: self.Linear_Seasonal = nn.ModuleList() self.Linear_Trend = nn.ModuleList() for i in range(self.channels): self.Linear_Seasonal.append( nn.Linear(self.seq_len, self.pred_len)) self.Linear_Trend.append( nn.Linear(self.seq_len, self.pred_len)) self.Linear_Seasonal[i].weight = nn.Parameter( (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len])) self.Linear_Trend[i].weight = nn.Parameter( (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len])) else: self.Linear_Seasonal = nn.Linear(self.seq_len, self.pred_len) self.Linear_Trend = nn.Linear(self.seq_len, self.pred_len) self.Linear_Seasonal.weight = nn.Parameter( (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len])) self.Linear_Trend.weight = nn.Parameter( (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len])) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear( configs.enc_in * configs.seq_len, configs.num_class) def encoder(self, x): seasonal_init, trend_init = self.decompsition(x) seasonal_init, trend_init = seasonal_init.permute( 0, 2, 1), trend_init.permute(0, 2, 1) if self.individual: seasonal_output = torch.zeros([seasonal_init.size(0), seasonal_init.size(1), self.pred_len], dtype=seasonal_init.dtype).to(seasonal_init.device) trend_output = torch.zeros([trend_init.size(0), trend_init.size(1), self.pred_len], dtype=trend_init.dtype).to(trend_init.device) for i in range(self.channels): seasonal_output[:, i, :] = self.Linear_Seasonal[i]( seasonal_init[:, i, :]) trend_output[:, i, :] = self.Linear_Trend[i]( trend_init[:, i, :]) else: seasonal_output = self.Linear_Seasonal(seasonal_init) trend_output = self.Linear_Trend(trend_init) x = seasonal_output + trend_output return x.permute(0, 2, 1) def forecast(self, x_enc): # Encoder return self.encoder(x_enc) def imputation(self, x_enc): # Encoder return self.encoder(x_enc) def anomaly_detection(self, x_enc): # Encoder return self.encoder(x_enc) def classification(self, x_enc): # Encoder enc_out = self.encoder(x_enc) # Output # (batch_size, seq_length * d_model) output = enc_out.reshape(enc_out.shape[0], -1) # (batch_size, num_classes) output = self.projection(output) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc) return dec_out # [B, N] return None library/models/ETSformer.py000066400000000000000000000107671443355502200162430ustar00rootroot00000000000000import torch import torch.nn as nn from layers.Embed import DataEmbedding from layers.ETSformer_EncDec import EncoderLayer, Encoder, DecoderLayer, Decoder, Transform class Model(nn.Module): """ Paper link: https://arxiv.org/abs/2202.01381 """ def __init__(self, configs): super(Model, self).__init__() self.task_name = configs.task_name self.seq_len = configs.seq_len self.label_len = configs.label_len if self.task_name == 'classification' or self.task_name == 'anomaly_detection' or self.task_name == 'imputation': self.pred_len = configs.seq_len else: self.pred_len = configs.pred_len assert configs.e_layers == configs.d_layers, "Encoder and decoder layers must be equal" # Embedding self.enc_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, configs.dropout) # Encoder self.encoder = Encoder( [ EncoderLayer( configs.d_model, configs.n_heads, configs.enc_in, configs.seq_len, self.pred_len, configs.top_k, dim_feedforward=configs.d_ff, dropout=configs.dropout, activation=configs.activation, ) for _ in range(configs.e_layers) ] ) # Decoder self.decoder = Decoder( [ DecoderLayer( configs.d_model, configs.n_heads, configs.c_out, self.pred_len, dropout=configs.dropout, ) for _ in range(configs.d_layers) ], ) self.transform = Transform(sigma=0.2) if self.task_name == 'classification': self.act = torch.nn.functional.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear(configs.d_model * configs.seq_len, configs.num_class) def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): with torch.no_grad(): if self.training: x_enc = self.transform.transform(x_enc) res = self.enc_embedding(x_enc, x_mark_enc) level, growths, seasons = self.encoder(res, x_enc, attn_mask=None) growth, season = self.decoder(growths, seasons) preds = level[:, -1:] + growth + season return preds def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): res = self.enc_embedding(x_enc, x_mark_enc) level, growths, seasons = self.encoder(res, x_enc, attn_mask=None) growth, season = self.decoder(growths, seasons) preds = level[:, -1:] + growth + season return preds def anomaly_detection(self, x_enc): res = self.enc_embedding(x_enc, None) level, growths, seasons = self.encoder(res, x_enc, attn_mask=None) growth, season = self.decoder(growths, seasons) preds = level[:, -1:] + growth + season return preds def classification(self, x_enc, x_mark_enc): res = self.enc_embedding(x_enc, None) _, growths, seasons = self.encoder(res, x_enc, attn_mask=None) growths = torch.sum(torch.stack(growths, 0), 0)[:, :self.seq_len, :] seasons = torch.sum(torch.stack(seasons, 0), 0)[:, :self.seq_len, :] enc_out = growths + seasons output = self.act(enc_out) # the output transformer encoder/decoder embeddings don't include non-linearity output = self.dropout(output) # Output output = output * x_mark_enc.unsqueeze(-1) # zero-out padding embeddings output = output.reshape(output.shape[0], -1) # (batch_size, seq_length * d_model) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/FEDformer.py000066400000000000000000000202571443355502200162010ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F from layers.Embed import DataEmbedding from layers.AutoCorrelation import AutoCorrelationLayer from layers.FourierCorrelation import FourierBlock, FourierCrossAttention from layers.MultiWaveletCorrelation import MultiWaveletCross, MultiWaveletTransform from layers.Autoformer_EncDec import Encoder, Decoder, EncoderLayer, DecoderLayer, my_Layernorm, series_decomp class Model(nn.Module): """ FEDformer performs the attention mechanism on frequency domain and achieved O(N) complexity Paper link: https://proceedings.mlr.press/v162/zhou22g.html """ def __init__(self, configs, version='fourier', mode_select='random', modes=32): """ version: str, for FEDformer, there are two versions to choose, options: [Fourier, Wavelets]. mode_select: str, for FEDformer, there are two mode selection method, options: [random, low]. modes: int, modes to be selected. """ super(Model, self).__init__() self.task_name = configs.task_name self.seq_len = configs.seq_len self.label_len = configs.label_len self.pred_len = configs.pred_len self.version = version self.mode_select = mode_select self.modes = modes # Decomp self.decomp = series_decomp(configs.moving_avg) self.enc_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, configs.dropout) self.dec_embedding = DataEmbedding(configs.dec_in, configs.d_model, configs.embed, configs.freq, configs.dropout) if self.version == 'Wavelets': encoder_self_att = MultiWaveletTransform(ich=configs.d_model, L=1, base='legendre') decoder_self_att = MultiWaveletTransform(ich=configs.d_model, L=1, base='legendre') decoder_cross_att = MultiWaveletCross(in_channels=configs.d_model, out_channels=configs.d_model, seq_len_q=self.seq_len // 2 + self.pred_len, seq_len_kv=self.seq_len, modes=self.modes, ich=configs.d_model, base='legendre', activation='tanh') else: encoder_self_att = FourierBlock(in_channels=configs.d_model, out_channels=configs.d_model, seq_len=self.seq_len, modes=self.modes, mode_select_method=self.mode_select) decoder_self_att = FourierBlock(in_channels=configs.d_model, out_channels=configs.d_model, seq_len=self.seq_len // 2 + self.pred_len, modes=self.modes, mode_select_method=self.mode_select) decoder_cross_att = FourierCrossAttention(in_channels=configs.d_model, out_channels=configs.d_model, seq_len_q=self.seq_len // 2 + self.pred_len, seq_len_kv=self.seq_len, modes=self.modes, mode_select_method=self.mode_select) # Encoder self.encoder = Encoder( [ EncoderLayer( AutoCorrelationLayer( encoder_self_att, # instead of multi-head attention in transformer configs.d_model, configs.n_heads), configs.d_model, configs.d_ff, moving_avg=configs.moving_avg, dropout=configs.dropout, activation=configs.activation ) for l in range(configs.e_layers) ], norm_layer=my_Layernorm(configs.d_model) ) # Decoder self.decoder = Decoder( [ DecoderLayer( AutoCorrelationLayer( decoder_self_att, configs.d_model, configs.n_heads), AutoCorrelationLayer( decoder_cross_att, configs.d_model, configs.n_heads), configs.d_model, configs.c_out, configs.d_ff, moving_avg=configs.moving_avg, dropout=configs.dropout, activation=configs.activation, ) for l in range(configs.d_layers) ], norm_layer=my_Layernorm(configs.d_model), projection=nn.Linear(configs.d_model, configs.c_out, bias=True) ) if self.task_name == 'imputation': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'anomaly_detection': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear(configs.d_model * configs.seq_len, configs.num_class) def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # decomp init mean = torch.mean(x_enc, dim=1).unsqueeze(1).repeat(1, self.pred_len, 1) seasonal_init, trend_init = self.decomp(x_enc) # x - moving_avg, moving_avg # decoder input trend_init = torch.cat([trend_init[:, -self.label_len:, :], mean], dim=1) seasonal_init = F.pad(seasonal_init[:, -self.label_len:, :], (0, 0, 0, self.pred_len)) # enc enc_out = self.enc_embedding(x_enc, x_mark_enc) dec_out = self.dec_embedding(seasonal_init, x_mark_dec) enc_out, attns = self.encoder(enc_out, attn_mask=None) # dec seasonal_part, trend_part = self.decoder(dec_out, enc_out, x_mask=None, cross_mask=None, trend=trend_init) # final dec_out = trend_part + seasonal_part return dec_out def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): # enc enc_out = self.enc_embedding(x_enc, x_mark_enc) enc_out, attns = self.encoder(enc_out, attn_mask=None) # final dec_out = self.projection(enc_out) return dec_out def anomaly_detection(self, x_enc): # enc enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None) # final dec_out = self.projection(enc_out) return dec_out def classification(self, x_enc, x_mark_enc): # enc enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None) # Output output = self.act(enc_out) output = self.dropout(output) output = output * x_mark_enc.unsqueeze(-1) output = output.reshape(output.shape[0], -1) output = self.projection(output) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/FiLM.py000066400000000000000000000266151443355502200151630ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F import numpy as np from scipy import signal from scipy import special as ss device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") def transition(N): Q = np.arange(N, dtype=np.float64) R = (2 * Q + 1)[:, None] # / theta j, i = np.meshgrid(Q, Q) A = np.where(i < j, -1, (-1.) ** (i - j + 1)) * R B = (-1.) ** Q[:, None] * R return A, B class HiPPO_LegT(nn.Module): def __init__(self, N, dt=1.0, discretization='bilinear'): """ N: the order of the HiPPO projection dt: discretization step size - should be roughly inverse to the length of the sequence """ super(HiPPO_LegT, self).__init__() self.N = N A, B = transition(N) C = np.ones((1, N)) D = np.zeros((1,)) A, B, _, _, _ = signal.cont2discrete((A, B, C, D), dt=dt, method=discretization) B = B.squeeze(-1) self.register_buffer('A', torch.Tensor(A).to(device)) self.register_buffer('B', torch.Tensor(B).to(device)) vals = np.arange(0.0, 1.0, dt) self.register_buffer('eval_matrix', torch.Tensor( ss.eval_legendre(np.arange(N)[:, None], 1 - 2 * vals).T).to(device)) def forward(self, inputs): """ inputs : (length, ...) output : (length, ..., N) where N is the order of the HiPPO projection """ c = torch.zeros(inputs.shape[:-1] + tuple([self.N])).to(device) cs = [] for f in inputs.permute([-1, 0, 1]): f = f.unsqueeze(-1) new = f @ self.B.unsqueeze(0) c = F.linear(c, self.A) + new cs.append(c) return torch.stack(cs, dim=0) def reconstruct(self, c): return (self.eval_matrix @ c.unsqueeze(-1)).squeeze(-1) class SpectralConv1d(nn.Module): def __init__(self, in_channels, out_channels, seq_len, ratio=0.5): """ 1D Fourier layer. It does FFT, linear transform, and Inverse FFT. """ super(SpectralConv1d, self).__init__() self.in_channels = in_channels self.out_channels = out_channels self.ratio = ratio self.modes = min(32, seq_len // 2) self.index = list(range(0, self.modes)) self.scale = (1 / (in_channels * out_channels)) self.weights_real = nn.Parameter( self.scale * torch.rand(in_channels, out_channels, len(self.index), dtype=torch.float)) self.weights_imag = nn.Parameter( self.scale * torch.rand(in_channels, out_channels, len(self.index), dtype=torch.float)) def compl_mul1d(self, order, x, weights_real, weights_imag): return torch.complex(torch.einsum(order, x.real, weights_real) - torch.einsum(order, x.imag, weights_imag), torch.einsum(order, x.real, weights_imag) + torch.einsum(order, x.imag, weights_real)) def forward(self, x): B, H, E, N = x.shape x_ft = torch.fft.rfft(x) out_ft = torch.zeros(B, H, self.out_channels, x.size(-1) // 2 + 1, device=x.device, dtype=torch.cfloat) a = x_ft[:, :, :, :self.modes] out_ft[:, :, :, :self.modes] = self.compl_mul1d("bjix,iox->bjox", a, self.weights_real, self.weights_imag) x = torch.fft.irfft(out_ft, n=x.size(-1)) return x class Model(nn.Module): """ Paper link: https://arxiv.org/abs/2205.08897 """ def __init__(self, configs): super(Model, self).__init__() self.task_name = configs.task_name self.configs = configs # self.modes = configs.modes self.seq_len = configs.seq_len self.label_len = configs.label_len self.pred_len = configs.seq_len if configs.pred_len == 0 else configs.pred_len self.seq_len_all = self.seq_len + self.label_len self.output_attention = configs.output_attention self.layers = configs.e_layers self.enc_in = configs.enc_in self.e_layers = configs.e_layers # b, s, f means b, f self.affine_weight = nn.Parameter(torch.ones(1, 1, configs.enc_in)) self.affine_bias = nn.Parameter(torch.zeros(1, 1, configs.enc_in)) self.multiscale = [1, 2, 4] self.window_size = [256] configs.ratio = 0.5 self.legts = nn.ModuleList( [HiPPO_LegT(N=n, dt=1. / self.pred_len / i) for n in self.window_size for i in self.multiscale]) self.spec_conv_1 = nn.ModuleList([SpectralConv1d(in_channels=n, out_channels=n, seq_len=min(self.pred_len, self.seq_len), ratio=configs.ratio) for n in self.window_size for _ in range(len(self.multiscale))]) self.mlp = nn.Linear(len(self.multiscale) * len(self.window_size), 1) if self.task_name == 'imputation' or self.task_name == 'anomaly_detection': self.projection = nn.Linear( configs.d_model, configs.c_out, bias=True) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear( configs.enc_in * configs.seq_len, configs.num_class) def forecast(self, x_enc, x_mark_enc, x_dec_true, x_mark_dec): # Normalization from Non-stationary Transformer means = x_enc.mean(1, keepdim=True).detach() x_enc = x_enc - means stdev = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach() x_enc /= stdev x_enc = x_enc * self.affine_weight + self.affine_bias x_decs = [] jump_dist = 0 for i in range(0, len(self.multiscale) * len(self.window_size)): x_in_len = self.multiscale[i % len(self.multiscale)] * self.pred_len x_in = x_enc[:, -x_in_len:] legt = self.legts[i] x_in_c = legt(x_in.transpose(1, 2)).permute([1, 2, 3, 0])[:, :, :, jump_dist:] out1 = self.spec_conv_1[i](x_in_c) if self.seq_len >= self.pred_len: x_dec_c = out1.transpose(2, 3)[:, :, self.pred_len - 1 - jump_dist, :] else: x_dec_c = out1.transpose(2, 3)[:, :, -1, :] x_dec = x_dec_c @ legt.eval_matrix[-self.pred_len:, :].T x_decs.append(x_dec) x_dec = torch.stack(x_decs, dim=-1) x_dec = self.mlp(x_dec).squeeze(-1).permute(0, 2, 1) # De-Normalization from Non-stationary Transformer x_dec = x_dec - self.affine_bias x_dec = x_dec / (self.affine_weight + 1e-10) x_dec = x_dec * stdev x_dec = x_dec + means return x_dec def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): # Normalization from Non-stationary Transformer means = x_enc.mean(1, keepdim=True).detach() x_enc = x_enc - means stdev = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach() x_enc /= stdev x_enc = x_enc * self.affine_weight + self.affine_bias x_decs = [] jump_dist = 0 for i in range(0, len(self.multiscale) * len(self.window_size)): x_in_len = self.multiscale[i % len(self.multiscale)] * self.pred_len x_in = x_enc[:, -x_in_len:] legt = self.legts[i] x_in_c = legt(x_in.transpose(1, 2)).permute([1, 2, 3, 0])[:, :, :, jump_dist:] out1 = self.spec_conv_1[i](x_in_c) if self.seq_len >= self.pred_len: x_dec_c = out1.transpose(2, 3)[:, :, self.pred_len - 1 - jump_dist, :] else: x_dec_c = out1.transpose(2, 3)[:, :, -1, :] x_dec = x_dec_c @ legt.eval_matrix[-self.pred_len:, :].T x_decs.append(x_dec) x_dec = torch.stack(x_decs, dim=-1) x_dec = self.mlp(x_dec).squeeze(-1).permute(0, 2, 1) # De-Normalization from Non-stationary Transformer x_dec = x_dec - self.affine_bias x_dec = x_dec / (self.affine_weight + 1e-10) x_dec = x_dec * stdev x_dec = x_dec + means return x_dec def anomaly_detection(self, x_enc): # Normalization from Non-stationary Transformer means = x_enc.mean(1, keepdim=True).detach() x_enc = x_enc - means stdev = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach() x_enc /= stdev x_enc = x_enc * self.affine_weight + self.affine_bias x_decs = [] jump_dist = 0 for i in range(0, len(self.multiscale) * len(self.window_size)): x_in_len = self.multiscale[i % len(self.multiscale)] * self.pred_len x_in = x_enc[:, -x_in_len:] legt = self.legts[i] x_in_c = legt(x_in.transpose(1, 2)).permute([1, 2, 3, 0])[:, :, :, jump_dist:] out1 = self.spec_conv_1[i](x_in_c) if self.seq_len >= self.pred_len: x_dec_c = out1.transpose(2, 3)[:, :, self.pred_len - 1 - jump_dist, :] else: x_dec_c = out1.transpose(2, 3)[:, :, -1, :] x_dec = x_dec_c @ legt.eval_matrix[-self.pred_len:, :].T x_decs.append(x_dec) x_dec = torch.stack(x_decs, dim=-1) x_dec = self.mlp(x_dec).squeeze(-1).permute(0, 2, 1) # De-Normalization from Non-stationary Transformer x_dec = x_dec - self.affine_bias x_dec = x_dec / (self.affine_weight + 1e-10) x_dec = x_dec * stdev x_dec = x_dec + means return x_dec def classification(self, x_enc, x_mark_enc): x_enc = x_enc * self.affine_weight + self.affine_bias x_decs = [] jump_dist = 0 for i in range(0, len(self.multiscale) * len(self.window_size)): x_in_len = self.multiscale[i % len(self.multiscale)] * self.pred_len x_in = x_enc[:, -x_in_len:] legt = self.legts[i] x_in_c = legt(x_in.transpose(1, 2)).permute([1, 2, 3, 0])[:, :, :, jump_dist:] out1 = self.spec_conv_1[i](x_in_c) if self.seq_len >= self.pred_len: x_dec_c = out1.transpose(2, 3)[:, :, self.pred_len - 1 - jump_dist, :] else: x_dec_c = out1.transpose(2, 3)[:, :, -1, :] x_dec = x_dec_c @ legt.eval_matrix[-self.pred_len:, :].T x_decs.append(x_dec) x_dec = torch.stack(x_decs, dim=-1) x_dec = self.mlp(x_dec).squeeze(-1).permute(0, 2, 1) # Output from Non-stationary Transformer output = self.act(x_dec) output = self.dropout(output) output = output * x_mark_enc.unsqueeze(-1) output = output.reshape(output.shape[0], -1) output = self.projection(output) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/Informer.py000066400000000000000000000144161443355502200161510ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F from layers.Transformer_EncDec import Decoder, DecoderLayer, Encoder, EncoderLayer, ConvLayer from layers.SelfAttention_Family import ProbAttention, AttentionLayer from layers.Embed import DataEmbedding class Model(nn.Module): """ Informer with Propspare attention in O(LlogL) complexity Paper link: https://ojs.aaai.org/index.php/AAAI/article/view/17325/17132 """ def __init__(self, configs): super(Model, self).__init__() self.task_name = configs.task_name self.pred_len = configs.pred_len self.label_len = configs.label_len # Embedding self.enc_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, configs.dropout) self.dec_embedding = DataEmbedding(configs.dec_in, configs.d_model, configs.embed, configs.freq, configs.dropout) # Encoder self.encoder = Encoder( [ EncoderLayer( AttentionLayer( ProbAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=configs.output_attention), configs.d_model, configs.n_heads), configs.d_model, configs.d_ff, dropout=configs.dropout, activation=configs.activation ) for l in range(configs.e_layers) ], [ ConvLayer( configs.d_model ) for l in range(configs.e_layers - 1) ] if configs.distil and ('forecast' in configs.task_name) else None, norm_layer=torch.nn.LayerNorm(configs.d_model) ) # Decoder self.decoder = Decoder( [ DecoderLayer( AttentionLayer( ProbAttention(True, configs.factor, attention_dropout=configs.dropout, output_attention=False), configs.d_model, configs.n_heads), AttentionLayer( ProbAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False), configs.d_model, configs.n_heads), configs.d_model, configs.d_ff, dropout=configs.dropout, activation=configs.activation, ) for l in range(configs.d_layers) ], norm_layer=torch.nn.LayerNorm(configs.d_model), projection=nn.Linear(configs.d_model, configs.c_out, bias=True) ) if self.task_name == 'imputation': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'anomaly_detection': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear(configs.d_model * configs.seq_len, configs.num_class) def long_forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): enc_out = self.enc_embedding(x_enc, x_mark_enc) dec_out = self.dec_embedding(x_dec, x_mark_dec) enc_out, attns = self.encoder(enc_out, attn_mask=None) dec_out = self.decoder(dec_out, enc_out, x_mask=None, cross_mask=None) return dec_out # [B, L, D] def short_forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # Normalization mean_enc = x_enc.mean(1, keepdim=True).detach() # B x 1 x E x_enc = x_enc - mean_enc std_enc = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach() # B x 1 x E x_enc = x_enc / std_enc enc_out = self.enc_embedding(x_enc, x_mark_enc) dec_out = self.dec_embedding(x_dec, x_mark_dec) enc_out, attns = self.encoder(enc_out, attn_mask=None) dec_out = self.decoder(dec_out, enc_out, x_mask=None, cross_mask=None) dec_out = dec_out * std_enc + mean_enc return dec_out # [B, L, D] def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): # enc enc_out = self.enc_embedding(x_enc, x_mark_enc) enc_out, attns = self.encoder(enc_out, attn_mask=None) # final dec_out = self.projection(enc_out) return dec_out def anomaly_detection(self, x_enc): # enc enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None) # final dec_out = self.projection(enc_out) return dec_out def classification(self, x_enc, x_mark_enc): # enc enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None) # Output output = self.act(enc_out) # the output transformer encoder/decoder embeddings don't include non-linearity output = self.dropout(output) output = output * x_mark_enc.unsqueeze(-1) # zero-out padding embeddings output = output.reshape(output.shape[0], -1) # (batch_size, seq_length * d_model) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast': dec_out = self.long_forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'short_term_forecast': dec_out = self.short_forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/LightTS.py000066400000000000000000000123341443355502200157030ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F class IEBlock(nn.Module): def __init__(self, input_dim, hid_dim, output_dim, num_node): super(IEBlock, self).__init__() self.input_dim = input_dim self.hid_dim = hid_dim self.output_dim = output_dim self.num_node = num_node self._build() def _build(self): self.spatial_proj = nn.Sequential( nn.Linear(self.input_dim, self.hid_dim), nn.LeakyReLU(), nn.Linear(self.hid_dim, self.hid_dim // 4) ) self.channel_proj = nn.Linear(self.num_node, self.num_node) torch.nn.init.eye_(self.channel_proj.weight) self.output_proj = nn.Linear(self.hid_dim // 4, self.output_dim) def forward(self, x): x = self.spatial_proj(x.permute(0, 2, 1)) x = x.permute(0, 2, 1) + self.channel_proj(x.permute(0, 2, 1)) x = self.output_proj(x.permute(0, 2, 1)) x = x.permute(0, 2, 1) return x class Model(nn.Module): """ Paper link: https://arxiv.org/abs/2207.01186 """ def __init__(self, configs, chunk_size=24): """ chunk_size: int, reshape T into [num_chunks, chunk_size] """ super(Model, self).__init__() self.task_name = configs.task_name self.seq_len = configs.seq_len if self.task_name == 'classification' or self.task_name == 'anomaly_detection' or self.task_name == 'imputation': self.pred_len = configs.seq_len else: self.pred_len = configs.pred_len if configs.task_name == 'long_term_forecast' or configs.task_name == 'short_term_forecast': self.chunk_size = min(configs.pred_len, configs.seq_len, chunk_size) else: self.chunk_size = min(configs.seq_len, chunk_size) assert (self.seq_len % self.chunk_size == 0) self.num_chunks = self.seq_len // self.chunk_size self.d_model = configs.d_model self.enc_in = configs.enc_in self.dropout = configs.dropout if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear(configs.enc_in * configs.seq_len, configs.num_class) self._build() def _build(self): self.layer_1 = IEBlock( input_dim=self.chunk_size, hid_dim=self.d_model // 4, output_dim=self.d_model // 4, num_node=self.num_chunks ) self.chunk_proj_1 = nn.Linear(self.num_chunks, 1) self.layer_2 = IEBlock( input_dim=self.chunk_size, hid_dim=self.d_model // 4, output_dim=self.d_model // 4, num_node=self.num_chunks ) self.chunk_proj_2 = nn.Linear(self.num_chunks, 1) self.layer_3 = IEBlock( input_dim=self.d_model // 2, hid_dim=self.d_model // 2, output_dim=self.pred_len, num_node=self.enc_in ) self.ar = nn.Linear(self.seq_len, self.pred_len) def encoder(self, x): B, T, N = x.size() highway = self.ar(x.permute(0, 2, 1)) highway = highway.permute(0, 2, 1) # continuous sampling x1 = x.reshape(B, self.num_chunks, self.chunk_size, N) x1 = x1.permute(0, 3, 2, 1) x1 = x1.reshape(-1, self.chunk_size, self.num_chunks) x1 = self.layer_1(x1) x1 = self.chunk_proj_1(x1).squeeze(dim=-1) # interval sampling x2 = x.reshape(B, self.chunk_size, self.num_chunks, N) x2 = x2.permute(0, 3, 1, 2) x2 = x2.reshape(-1, self.chunk_size, self.num_chunks) x2 = self.layer_2(x2) x2 = self.chunk_proj_2(x2).squeeze(dim=-1) x3 = torch.cat([x1, x2], dim=-1) x3 = x3.reshape(B, N, -1) x3 = x3.permute(0, 2, 1) out = self.layer_3(x3) out = out + highway return out def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): return self.encoder(x_enc) def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): return self.encoder(x_enc) def anomaly_detection(self, x_enc): return self.encoder(x_enc) def classification(self, x_enc, x_mark_enc): enc_out = self.encoder(x_enc) # Output output = enc_out.reshape(enc_out.shape[0], -1) # (batch_size, seq_length * d_model) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/MICN.py000066400000000000000000000232551443355502200151170ustar00rootroot00000000000000import torch import torch.nn as nn from layers.Embed import DataEmbedding from layers.Autoformer_EncDec import series_decomp, series_decomp_multi import torch.nn.functional as F class MIC(nn.Module): """ MIC layer to extract local and global features """ def __init__(self, feature_size=512, n_heads=8, dropout=0.05, decomp_kernel=[32], conv_kernel=[24], isometric_kernel=[18, 6], device='cuda'): super(MIC, self).__init__() self.conv_kernel = conv_kernel self.device = device # isometric convolution self.isometric_conv = nn.ModuleList([nn.Conv1d(in_channels=feature_size, out_channels=feature_size, kernel_size=i, padding=0, stride=1) for i in isometric_kernel]) # downsampling convolution: padding=i//2, stride=i self.conv = nn.ModuleList([nn.Conv1d(in_channels=feature_size, out_channels=feature_size, kernel_size=i, padding=i // 2, stride=i) for i in conv_kernel]) # upsampling convolution self.conv_trans = nn.ModuleList([nn.ConvTranspose1d(in_channels=feature_size, out_channels=feature_size, kernel_size=i, padding=0, stride=i) for i in conv_kernel]) self.decomp = nn.ModuleList([series_decomp(k) for k in decomp_kernel]) self.merge = torch.nn.Conv2d(in_channels=feature_size, out_channels=feature_size, kernel_size=(len(self.conv_kernel), 1)) # feedforward network self.conv1 = nn.Conv1d(in_channels=feature_size, out_channels=feature_size * 4, kernel_size=1) self.conv2 = nn.Conv1d(in_channels=feature_size * 4, out_channels=feature_size, kernel_size=1) self.norm1 = nn.LayerNorm(feature_size) self.norm2 = nn.LayerNorm(feature_size) self.norm = torch.nn.LayerNorm(feature_size) self.act = torch.nn.Tanh() self.drop = torch.nn.Dropout(0.05) def conv_trans_conv(self, input, conv1d, conv1d_trans, isometric): batch, seq_len, channel = input.shape x = input.permute(0, 2, 1) # downsampling convolution x1 = self.drop(self.act(conv1d(x))) x = x1 # isometric convolution zeros = torch.zeros((x.shape[0], x.shape[1], x.shape[2] - 1), device=self.device) x = torch.cat((zeros, x), dim=-1) x = self.drop(self.act(isometric(x))) x = self.norm((x + x1).permute(0, 2, 1)).permute(0, 2, 1) # upsampling convolution x = self.drop(self.act(conv1d_trans(x))) x = x[:, :, :seq_len] # truncate x = self.norm(x.permute(0, 2, 1) + input) return x def forward(self, src): # multi-scale multi = [] for i in range(len(self.conv_kernel)): src_out, trend1 = self.decomp[i](src) src_out = self.conv_trans_conv(src_out, self.conv[i], self.conv_trans[i], self.isometric_conv[i]) multi.append(src_out) # merge mg = torch.tensor([], device=self.device) for i in range(len(self.conv_kernel)): mg = torch.cat((mg, multi[i].unsqueeze(1)), dim=1) mg = self.merge(mg.permute(0, 3, 1, 2)).squeeze(-2).permute(0, 2, 1) y = self.norm1(mg) y = self.conv2(self.conv1(y.transpose(-1, 1))).transpose(-1, 1) return self.norm2(mg + y) class SeasonalPrediction(nn.Module): def __init__(self, embedding_size=512, n_heads=8, dropout=0.05, d_layers=1, decomp_kernel=[32], c_out=1, conv_kernel=[2, 4], isometric_kernel=[18, 6], device='cuda'): super(SeasonalPrediction, self).__init__() self.mic = nn.ModuleList([MIC(feature_size=embedding_size, n_heads=n_heads, decomp_kernel=decomp_kernel, conv_kernel=conv_kernel, isometric_kernel=isometric_kernel, device=device) for i in range(d_layers)]) self.projection = nn.Linear(embedding_size, c_out) def forward(self, dec): for mic_layer in self.mic: dec = mic_layer(dec) return self.projection(dec) class Model(nn.Module): """ Paper link: https://openreview.net/pdf?id=zt53IDUR1U """ def __init__(self, configs, conv_kernel=[12, 16]): """ conv_kernel: downsampling and upsampling convolution kernel_size """ super(Model, self).__init__() decomp_kernel = [] # kernel of decomposition operation isometric_kernel = [] # kernel of isometric convolution for ii in conv_kernel: if ii % 2 == 0: # the kernel of decomposition operation must be odd decomp_kernel.append(ii + 1) isometric_kernel.append((configs.seq_len + configs.pred_len + ii) // ii) else: decomp_kernel.append(ii) isometric_kernel.append((configs.seq_len + configs.pred_len + ii - 1) // ii) self.task_name = configs.task_name self.pred_len = configs.pred_len self.seq_len = configs.seq_len # Multiple Series decomposition block from FEDformer self.decomp_multi = series_decomp_multi(decomp_kernel) # embedding self.dec_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, configs.dropout) self.conv_trans = SeasonalPrediction(embedding_size=configs.d_model, n_heads=configs.n_heads, dropout=configs.dropout, d_layers=configs.d_layers, decomp_kernel=decomp_kernel, c_out=configs.c_out, conv_kernel=conv_kernel, isometric_kernel=isometric_kernel, device=torch.device('cuda:0')) if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': # refer to DLinear self.regression = nn.Linear(configs.seq_len, configs.pred_len) self.regression.weight = nn.Parameter( (1 / configs.pred_len) * torch.ones([configs.pred_len, configs.seq_len]), requires_grad=True) if self.task_name == 'imputation': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'anomaly_detection': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear(configs.c_out * configs.seq_len, configs.num_class) def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # Multi-scale Hybrid Decomposition seasonal_init_enc, trend = self.decomp_multi(x_enc) trend = self.regression(trend.permute(0, 2, 1)).permute(0, 2, 1) # embedding zeros = torch.zeros([x_dec.shape[0], self.pred_len, x_dec.shape[2]], device=x_enc.device) seasonal_init_dec = torch.cat([seasonal_init_enc[:, -self.seq_len:, :], zeros], dim=1) dec_out = self.dec_embedding(seasonal_init_dec, x_mark_dec) dec_out = self.conv_trans(dec_out) dec_out = dec_out[:, -self.pred_len:, :] + trend[:, -self.pred_len:, :] return dec_out def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): # Multi-scale Hybrid Decomposition seasonal_init_enc, trend = self.decomp_multi(x_enc) # embedding dec_out = self.dec_embedding(seasonal_init_enc, x_mark_dec) dec_out = self.conv_trans(dec_out) dec_out = dec_out + trend return dec_out def anomaly_detection(self, x_enc): # Multi-scale Hybrid Decomposition seasonal_init_enc, trend = self.decomp_multi(x_enc) # embedding dec_out = self.dec_embedding(seasonal_init_enc, None) dec_out = self.conv_trans(dec_out) dec_out = dec_out + trend return dec_out def classification(self, x_enc, x_mark_enc): # Multi-scale Hybrid Decomposition seasonal_init_enc, trend = self.decomp_multi(x_enc) # embedding dec_out = self.dec_embedding(seasonal_init_enc, None) dec_out = self.conv_trans(dec_out) dec_out = dec_out + trend # Output from Non-stationary Transformer output = self.act(dec_out) # the output transformer encoder/decoder embeddings don't include non-linearity output = self.dropout(output) output = output * x_mark_enc.unsqueeze(-1) # zero-out padding embeddings output = output.reshape(output.shape[0], -1) # (batch_size, seq_length * d_model) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation( x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/Nonstationary_Transformer.py000066400000000000000000000231031443355502200216130ustar00rootroot00000000000000import torch import torch.nn as nn from layers.Transformer_EncDec import Decoder, DecoderLayer, Encoder, EncoderLayer from layers.SelfAttention_Family import DSAttention, AttentionLayer from layers.Embed import DataEmbedding import torch.nn.functional as F class Projector(nn.Module): ''' MLP to learn the De-stationary factors Paper link: https://openreview.net/pdf?id=ucNDIDRNjjv ''' def __init__(self, enc_in, seq_len, hidden_dims, hidden_layers, output_dim, kernel_size=3): super(Projector, self).__init__() padding = 1 if torch.__version__ >= '1.5.0' else 2 self.series_conv = nn.Conv1d(in_channels=seq_len, out_channels=1, kernel_size=kernel_size, padding=padding, padding_mode='circular', bias=False) layers = [nn.Linear(2 * enc_in, hidden_dims[0]), nn.ReLU()] for i in range(hidden_layers - 1): layers += [nn.Linear(hidden_dims[i], hidden_dims[i + 1]), nn.ReLU()] layers += [nn.Linear(hidden_dims[-1], output_dim, bias=False)] self.backbone = nn.Sequential(*layers) def forward(self, x, stats): # x: B x S x E # stats: B x 1 x E # y: B x O batch_size = x.shape[0] x = self.series_conv(x) # B x 1 x E x = torch.cat([x, stats], dim=1) # B x 2 x E x = x.view(batch_size, -1) # B x 2E y = self.backbone(x) # B x O return y class Model(nn.Module): """ Paper link: https://openreview.net/pdf?id=ucNDIDRNjjv """ def __init__(self, configs): super(Model, self).__init__() self.task_name = configs.task_name self.pred_len = configs.pred_len self.seq_len = configs.seq_len self.label_len = configs.label_len self.output_attention = configs.output_attention # Embedding self.enc_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, configs.dropout) # Encoder self.encoder = Encoder( [ EncoderLayer( AttentionLayer( DSAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=configs.output_attention), configs.d_model, configs.n_heads), configs.d_model, configs.d_ff, dropout=configs.dropout, activation=configs.activation ) for l in range(configs.e_layers) ], norm_layer=torch.nn.LayerNorm(configs.d_model) ) # Decoder if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': self.dec_embedding = DataEmbedding(configs.dec_in, configs.d_model, configs.embed, configs.freq, configs.dropout) self.decoder = Decoder( [ DecoderLayer( AttentionLayer( DSAttention(True, configs.factor, attention_dropout=configs.dropout, output_attention=False), configs.d_model, configs.n_heads), AttentionLayer( DSAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False), configs.d_model, configs.n_heads), configs.d_model, configs.d_ff, dropout=configs.dropout, activation=configs.activation, ) for l in range(configs.d_layers) ], norm_layer=torch.nn.LayerNorm(configs.d_model), projection=nn.Linear(configs.d_model, configs.c_out, bias=True) ) if self.task_name == 'imputation': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'anomaly_detection': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear(configs.d_model * configs.seq_len, configs.num_class) self.tau_learner = Projector(enc_in=configs.enc_in, seq_len=configs.seq_len, hidden_dims=configs.p_hidden_dims, hidden_layers=configs.p_hidden_layers, output_dim=1) self.delta_learner = Projector(enc_in=configs.enc_in, seq_len=configs.seq_len, hidden_dims=configs.p_hidden_dims, hidden_layers=configs.p_hidden_layers, output_dim=configs.seq_len) def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): x_raw = x_enc.clone().detach() # Normalization mean_enc = x_enc.mean(1, keepdim=True).detach() # B x 1 x E x_enc = x_enc - mean_enc std_enc = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach() # B x 1 x E x_enc = x_enc / std_enc # B x S x E, B x 1 x E -> B x 1, positive scalar tau = self.tau_learner(x_raw, std_enc).exp() # B x S x E, B x 1 x E -> B x S delta = self.delta_learner(x_raw, mean_enc) x_dec_new = torch.cat([x_enc[:, -self.label_len:, :], torch.zeros_like(x_dec[:, -self.pred_len:, :])], dim=1).to(x_enc.device).clone() enc_out = self.enc_embedding(x_enc, x_mark_enc) enc_out, attns = self.encoder(enc_out, attn_mask=None, tau=tau, delta=delta) dec_out = self.dec_embedding(x_dec_new, x_mark_dec) dec_out = self.decoder(dec_out, enc_out, x_mask=None, cross_mask=None, tau=tau, delta=delta) dec_out = dec_out * std_enc + mean_enc return dec_out def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): x_raw = x_enc.clone().detach() # Normalization mean_enc = torch.sum(x_enc, dim=1) / torch.sum(mask == 1, dim=1) mean_enc = mean_enc.unsqueeze(1).detach() x_enc = x_enc - mean_enc x_enc = x_enc.masked_fill(mask == 0, 0) std_enc = torch.sqrt(torch.sum(x_enc * x_enc, dim=1) / torch.sum(mask == 1, dim=1) + 1e-5) std_enc = std_enc.unsqueeze(1).detach() x_enc /= std_enc # B x S x E, B x 1 x E -> B x 1, positive scalar tau = self.tau_learner(x_raw, std_enc).exp() # B x S x E, B x 1 x E -> B x S delta = self.delta_learner(x_raw, mean_enc) enc_out = self.enc_embedding(x_enc, x_mark_enc) enc_out, attns = self.encoder(enc_out, attn_mask=None, tau=tau, delta=delta) dec_out = self.projection(enc_out) dec_out = dec_out * std_enc + mean_enc return dec_out def anomaly_detection(self, x_enc): x_raw = x_enc.clone().detach() # Normalization mean_enc = x_enc.mean(1, keepdim=True).detach() # B x 1 x E x_enc = x_enc - mean_enc std_enc = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach() # B x 1 x E x_enc = x_enc / std_enc # B x S x E, B x 1 x E -> B x 1, positive scalar tau = self.tau_learner(x_raw, std_enc).exp() # B x S x E, B x 1 x E -> B x S delta = self.delta_learner(x_raw, mean_enc) # embedding enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None, tau=tau, delta=delta) dec_out = self.projection(enc_out) dec_out = dec_out * std_enc + mean_enc return dec_out def classification(self, x_enc, x_mark_enc): x_raw = x_enc.clone().detach() # Normalization mean_enc = x_enc.mean(1, keepdim=True).detach() # B x 1 x E std_enc = torch.sqrt( torch.var(x_enc - mean_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach() # B x 1 x E # B x S x E, B x 1 x E -> B x 1, positive scalar tau = self.tau_learner(x_raw, std_enc).exp() # B x S x E, B x 1 x E -> B x S delta = self.delta_learner(x_raw, mean_enc) # embedding enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None, tau=tau, delta=delta) # Output output = self.act(enc_out) # the output transformer encoder/decoder embeddings don't include non-linearity output = self.dropout(output) output = output * x_mark_enc.unsqueeze(-1) # zero-out padding embeddings # (batch_size, seq_length * d_model) output = output.reshape(output.shape[0], -1) # (batch_size, num_classes) output = self.projection(output) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, L, D] return None library/models/PatchTST.py000066400000000000000000000210501443355502200160120ustar00rootroot00000000000000import torch from torch import nn from layers.Transformer_EncDec import Encoder, EncoderLayer from layers.SelfAttention_Family import FullAttention, AttentionLayer from layers.Embed import PatchEmbedding class FlattenHead(nn.Module): def __init__(self, n_vars, nf, target_window, head_dropout=0): super().__init__() self.n_vars = n_vars self.flatten = nn.Flatten(start_dim=-2) self.linear = nn.Linear(nf, target_window) self.dropout = nn.Dropout(head_dropout) def forward(self, x): # x: [bs x nvars x d_model x patch_num] x = self.flatten(x) x = self.linear(x) x = self.dropout(x) return x class Model(nn.Module): """ Paper link: https://arxiv.org/pdf/2211.14730.pdf """ def __init__(self, configs, patch_len=16, stride=8): """ patch_len: int, patch len for patch_embedding stride: int, stride for patch_embedding """ super().__init__() self.task_name = configs.task_name self.seq_len = configs.seq_len self.pred_len = configs.pred_len padding = stride # patching and embedding self.patch_embedding = PatchEmbedding( configs.d_model, patch_len, stride, padding, configs.dropout) # Encoder self.encoder = Encoder( [ EncoderLayer( AttentionLayer( FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=configs.output_attention), configs.d_model, configs.n_heads), configs.d_model, configs.d_ff, dropout=configs.dropout, activation=configs.activation ) for l in range(configs.e_layers) ], norm_layer=torch.nn.LayerNorm(configs.d_model) ) # Prediction Head self.head_nf = configs.d_model * \ int((configs.seq_len - patch_len) / stride + 2) if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': self.head = FlattenHead(configs.enc_in, self.head_nf, configs.pred_len, head_dropout=configs.dropout) elif self.task_name == 'imputation' or self.task_name == 'anomaly_detection': self.head = FlattenHead(configs.enc_in, self.head_nf, configs.seq_len, head_dropout=configs.dropout) elif self.task_name == 'classification': self.flatten = nn.Flatten(start_dim=-2) self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear( self.head_nf * configs.enc_in, configs.num_class) def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # Normalization from Non-stationary Transformer means = x_enc.mean(1, keepdim=True).detach() x_enc = x_enc - means stdev = torch.sqrt( torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5) x_enc /= stdev # do patching and embedding x_enc = x_enc.permute(0, 2, 1) # u: [bs * nvars x patch_num x d_model] enc_out, n_vars = self.patch_embedding(x_enc) # Encoder # z: [bs * nvars x patch_num x d_model] enc_out, attns = self.encoder(enc_out) # z: [bs x nvars x patch_num x d_model] enc_out = torch.reshape( enc_out, (-1, n_vars, enc_out.shape[-2], enc_out.shape[-1])) # z: [bs x nvars x d_model x patch_num] enc_out = enc_out.permute(0, 1, 3, 2) # Decoder dec_out = self.head(enc_out) # z: [bs x nvars x target_window] dec_out = dec_out.permute(0, 2, 1) # De-Normalization from Non-stationary Transformer dec_out = dec_out * \ (stdev[:, 0, :].unsqueeze(1).repeat(1, self.pred_len, 1)) dec_out = dec_out + \ (means[:, 0, :].unsqueeze(1).repeat(1, self.pred_len, 1)) return dec_out def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): # Normalization from Non-stationary Transformer means = torch.sum(x_enc, dim=1) / torch.sum(mask == 1, dim=1) means = means.unsqueeze(1).detach() x_enc = x_enc - means x_enc = x_enc.masked_fill(mask == 0, 0) stdev = torch.sqrt(torch.sum(x_enc * x_enc, dim=1) / torch.sum(mask == 1, dim=1) + 1e-5) stdev = stdev.unsqueeze(1).detach() x_enc /= stdev # do patching and embedding x_enc = x_enc.permute(0, 2, 1) # u: [bs * nvars x patch_num x d_model] enc_out, n_vars = self.patch_embedding(x_enc) # Encoder # z: [bs * nvars x patch_num x d_model] enc_out, attns = self.encoder(enc_out) # z: [bs x nvars x patch_num x d_model] enc_out = torch.reshape( enc_out, (-1, n_vars, enc_out.shape[-2], enc_out.shape[-1])) # z: [bs x nvars x d_model x patch_num] enc_out = enc_out.permute(0, 1, 3, 2) # Decoder dec_out = self.head(enc_out) # z: [bs x nvars x target_window] dec_out = dec_out.permute(0, 2, 1) # De-Normalization from Non-stationary Transformer dec_out = dec_out * \ (stdev[:, 0, :].unsqueeze(1).repeat(1, self.seq_len, 1)) dec_out = dec_out + \ (means[:, 0, :].unsqueeze(1).repeat(1, self.seq_len, 1)) return dec_out def anomaly_detection(self, x_enc): # Normalization from Non-stationary Transformer means = x_enc.mean(1, keepdim=True).detach() x_enc = x_enc - means stdev = torch.sqrt( torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5) x_enc /= stdev # do patching and embedding x_enc = x_enc.permute(0, 2, 1) # u: [bs * nvars x patch_num x d_model] enc_out, n_vars = self.patch_embedding(x_enc) # Encoder # z: [bs * nvars x patch_num x d_model] enc_out, attns = self.encoder(enc_out) # z: [bs x nvars x patch_num x d_model] enc_out = torch.reshape( enc_out, (-1, n_vars, enc_out.shape[-2], enc_out.shape[-1])) # z: [bs x nvars x d_model x patch_num] enc_out = enc_out.permute(0, 1, 3, 2) # Decoder dec_out = self.head(enc_out) # z: [bs x nvars x target_window] dec_out = dec_out.permute(0, 2, 1) # De-Normalization from Non-stationary Transformer dec_out = dec_out * \ (stdev[:, 0, :].unsqueeze(1).repeat(1, self.seq_len, 1)) dec_out = dec_out + \ (means[:, 0, :].unsqueeze(1).repeat(1, self.seq_len, 1)) return dec_out def classification(self, x_enc, x_mark_enc): # Normalization from Non-stationary Transformer means = x_enc.mean(1, keepdim=True).detach() x_enc = x_enc - means stdev = torch.sqrt( torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5) x_enc /= stdev # do patching and embedding x_enc = x_enc.permute(0, 2, 1) # u: [bs * nvars x patch_num x d_model] enc_out, n_vars = self.patch_embedding(x_enc) # Encoder # z: [bs * nvars x patch_num x d_model] enc_out, attns = self.encoder(enc_out) # z: [bs x nvars x patch_num x d_model] enc_out = torch.reshape( enc_out, (-1, n_vars, enc_out.shape[-2], enc_out.shape[-1])) # z: [bs x nvars x d_model x patch_num] enc_out = enc_out.permute(0, 1, 3, 2) # Decoder output = self.flatten(enc_out) output = self.dropout(output) output = output.reshape(output.shape[0], -1) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation( x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/Pyraformer.py000066400000000000000000000101671443355502200165150ustar00rootroot00000000000000import torch import torch.nn as nn from layers.Pyraformer_EncDec import Encoder class Model(nn.Module): """ Pyraformer: Pyramidal attention to reduce complexity Paper link: https://openreview.net/pdf?id=0EXmFzUn5I """ def __init__(self, configs, window_size=[4,4], inner_size=5): """ window_size: list, the downsample window size in pyramidal attention. inner_size: int, the size of neighbour attention """ super().__init__() self.task_name = configs.task_name self.pred_len = configs.pred_len self.d_model = configs.d_model if self.task_name == 'short_term_forecast': window_size = [2,2] self.encoder = Encoder(configs, window_size, inner_size) if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': self.projection = nn.Linear( (len(window_size)+1)*self.d_model, self.pred_len * configs.enc_in) elif self.task_name == 'imputation' or self.task_name == 'anomaly_detection': self.projection = nn.Linear( (len(window_size)+1)*self.d_model, configs.enc_in, bias=True) elif self.task_name == 'classification': self.act = torch.nn.functional.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear( (len(window_size)+1)*self.d_model * configs.seq_len, configs.num_class) def long_forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): enc_out = self.encoder(x_enc, x_mark_enc)[:, -1, :] dec_out = self.projection(enc_out).view( enc_out.size(0), self.pred_len, -1) return dec_out def short_forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): # Normalization mean_enc = x_enc.mean(1, keepdim=True).detach() # B x 1 x E x_enc = x_enc - mean_enc std_enc = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach() # B x 1 x E x_enc = x_enc / std_enc enc_out = self.encoder(x_enc, x_mark_enc)[:, -1, :] dec_out = self.projection(enc_out).view( enc_out.size(0), self.pred_len, -1) dec_out = dec_out * std_enc + mean_enc return dec_out def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): enc_out = self.encoder(x_enc, x_mark_enc) dec_out = self.projection(enc_out) return dec_out def anomaly_detection(self, x_enc, x_mark_enc): enc_out = self.encoder(x_enc, x_mark_enc) dec_out = self.projection(enc_out) return dec_out def classification(self, x_enc, x_mark_enc): # enc enc_out = self.encoder(x_enc, x_mark_enc=None) # Output # the output transformer encoder/decoder embeddings don't include non-linearity output = self.act(enc_out) output = self.dropout(output) # zero-out padding embeddings output = output * x_mark_enc.unsqueeze(-1) # (batch_size, seq_length * d_model) output = output.reshape(output.shape[0], -1) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast': dec_out = self.long_forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'short_term_forecast': dec_out = self.short_forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation( x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc, x_mark_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/Reformer.py000066400000000000000000000117421443355502200161500ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F from layers.Transformer_EncDec import Encoder, EncoderLayer from layers.SelfAttention_Family import ReformerLayer from layers.Embed import DataEmbedding class Model(nn.Module): """ Reformer with O(LlogL) complexity Paper link: https://openreview.net/forum?id=rkgNKkHtvB """ def __init__(self, configs, bucket_size=4, n_hashes=4): """ bucket_size: int, n_hashes: int, """ super(Model, self).__init__() self.task_name = configs.task_name self.pred_len = configs.pred_len self.seq_len = configs.seq_len self.enc_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, configs.dropout) # Encoder self.encoder = Encoder( [ EncoderLayer( ReformerLayer(None, configs.d_model, configs.n_heads, bucket_size=bucket_size, n_hashes=n_hashes), configs.d_model, configs.d_ff, dropout=configs.dropout, activation=configs.activation ) for l in range(configs.e_layers) ], norm_layer=torch.nn.LayerNorm(configs.d_model) ) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear( configs.d_model * configs.seq_len, configs.num_class) else: self.projection = nn.Linear( configs.d_model, configs.c_out, bias=True) def long_forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # add placeholder x_enc = torch.cat([x_enc, x_dec[:, -self.pred_len:, :]], dim=1) if x_mark_enc is not None: x_mark_enc = torch.cat( [x_mark_enc, x_mark_dec[:, -self.pred_len:, :]], dim=1) enc_out = self.enc_embedding(x_enc, x_mark_enc) # [B,T,C] enc_out, attns = self.encoder(enc_out, attn_mask=None) dec_out = self.projection(enc_out) return dec_out # [B, L, D] def short_forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # Normalization mean_enc = x_enc.mean(1, keepdim=True).detach() # B x 1 x E x_enc = x_enc - mean_enc std_enc = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach() # B x 1 x E x_enc = x_enc / std_enc # add placeholder x_enc = torch.cat([x_enc, x_dec[:, -self.pred_len:, :]], dim=1) if x_mark_enc is not None: x_mark_enc = torch.cat( [x_mark_enc, x_mark_dec[:, -self.pred_len:, :]], dim=1) enc_out = self.enc_embedding(x_enc, x_mark_enc) # [B,T,C] enc_out, attns = self.encoder(enc_out, attn_mask=None) dec_out = self.projection(enc_out) dec_out = dec_out * std_enc + mean_enc return dec_out # [B, L, D] def imputation(self, x_enc, x_mark_enc): enc_out = self.enc_embedding(x_enc, x_mark_enc) # [B,T,C] enc_out, attns = self.encoder(enc_out) enc_out = self.projection(enc_out) return enc_out # [B, L, D] def anomaly_detection(self, x_enc): enc_out = self.enc_embedding(x_enc, None) # [B,T,C] enc_out, attns = self.encoder(enc_out) enc_out = self.projection(enc_out) return enc_out # [B, L, D] def classification(self, x_enc, x_mark_enc): # enc enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out) # Output # the output transformer encoder/decoder embeddings don't include non-linearity output = self.act(enc_out) output = self.dropout(output) # zero-out padding embeddings output = output * x_mark_enc.unsqueeze(-1) # (batch_size, seq_length * d_model) output = output.reshape(output.shape[0], -1) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast': dec_out = self.long_forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'short_term_forecast': dec_out = self.short_forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc, x_mark_enc) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/TimesNet.py000066400000000000000000000207541443355502200161220ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F import torch.fft from layers.Embed import DataEmbedding from layers.Conv_Blocks import Inception_Block_V1 def FFT_for_Period(x, k=2): # [B, T, C] xf = torch.fft.rfft(x, dim=1) # find period by amplitudes frequency_list = abs(xf).mean(0).mean(-1) frequency_list[0] = 0 _, top_list = torch.topk(frequency_list, k) top_list = top_list.detach().cpu().numpy() period = x.shape[1] // top_list return period, abs(xf).mean(-1)[:, top_list] class TimesBlock(nn.Module): def __init__(self, configs): super(TimesBlock, self).__init__() self.seq_len = configs.seq_len self.pred_len = configs.pred_len self.k = configs.top_k # parameter-efficient design self.conv = nn.Sequential( Inception_Block_V1(configs.d_model, configs.d_ff, num_kernels=configs.num_kernels), nn.GELU(), Inception_Block_V1(configs.d_ff, configs.d_model, num_kernels=configs.num_kernels) ) def forward(self, x): B, T, N = x.size() period_list, period_weight = FFT_for_Period(x, self.k) res = [] for i in range(self.k): period = period_list[i] # padding if (self.seq_len + self.pred_len) % period != 0: length = ( ((self.seq_len + self.pred_len) // period) + 1) * period padding = torch.zeros([x.shape[0], (length - (self.seq_len + self.pred_len)), x.shape[2]]).to(x.device) out = torch.cat([x, padding], dim=1) else: length = (self.seq_len + self.pred_len) out = x # reshape out = out.reshape(B, length // period, period, N).permute(0, 3, 1, 2).contiguous() # 2D conv: from 1d Variation to 2d Variation out = self.conv(out) # reshape back out = out.permute(0, 2, 3, 1).reshape(B, -1, N) res.append(out[:, :(self.seq_len + self.pred_len), :]) res = torch.stack(res, dim=-1) # adaptive aggregation period_weight = F.softmax(period_weight, dim=1) period_weight = period_weight.unsqueeze( 1).unsqueeze(1).repeat(1, T, N, 1) res = torch.sum(res * period_weight, -1) # residual connection res = res + x return res class Model(nn.Module): """ Paper link: https://openreview.net/pdf?id=ju_Uqw384Oq """ def __init__(self, configs): super(Model, self).__init__() self.configs = configs self.task_name = configs.task_name self.seq_len = configs.seq_len self.label_len = configs.label_len self.pred_len = configs.pred_len self.model = nn.ModuleList([TimesBlock(configs) for _ in range(configs.e_layers)]) self.enc_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, configs.dropout) self.layer = configs.e_layers self.layer_norm = nn.LayerNorm(configs.d_model) if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': self.predict_linear = nn.Linear( self.seq_len, self.pred_len + self.seq_len) self.projection = nn.Linear( configs.d_model, configs.c_out, bias=True) if self.task_name == 'imputation' or self.task_name == 'anomaly_detection': self.projection = nn.Linear( configs.d_model, configs.c_out, bias=True) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear( configs.d_model * configs.seq_len, configs.num_class) def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # Normalization from Non-stationary Transformer means = x_enc.mean(1, keepdim=True).detach() x_enc = x_enc - means stdev = torch.sqrt( torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5) x_enc /= stdev # embedding enc_out = self.enc_embedding(x_enc, x_mark_enc) # [B,T,C] enc_out = self.predict_linear(enc_out.permute(0, 2, 1)).permute( 0, 2, 1) # align temporal dimension # TimesNet for i in range(self.layer): enc_out = self.layer_norm(self.model[i](enc_out)) # porject back dec_out = self.projection(enc_out) # De-Normalization from Non-stationary Transformer dec_out = dec_out * \ (stdev[:, 0, :].unsqueeze(1).repeat( 1, self.pred_len + self.seq_len, 1)) dec_out = dec_out + \ (means[:, 0, :].unsqueeze(1).repeat( 1, self.pred_len + self.seq_len, 1)) return dec_out def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): # Normalization from Non-stationary Transformer means = torch.sum(x_enc, dim=1) / torch.sum(mask == 1, dim=1) means = means.unsqueeze(1).detach() x_enc = x_enc - means x_enc = x_enc.masked_fill(mask == 0, 0) stdev = torch.sqrt(torch.sum(x_enc * x_enc, dim=1) / torch.sum(mask == 1, dim=1) + 1e-5) stdev = stdev.unsqueeze(1).detach() x_enc /= stdev # embedding enc_out = self.enc_embedding(x_enc, x_mark_enc) # [B,T,C] # TimesNet for i in range(self.layer): enc_out = self.layer_norm(self.model[i](enc_out)) # porject back dec_out = self.projection(enc_out) # De-Normalization from Non-stationary Transformer dec_out = dec_out * \ (stdev[:, 0, :].unsqueeze(1).repeat( 1, self.pred_len + self.seq_len, 1)) dec_out = dec_out + \ (means[:, 0, :].unsqueeze(1).repeat( 1, self.pred_len + self.seq_len, 1)) return dec_out def anomaly_detection(self, x_enc): # Normalization from Non-stationary Transformer means = x_enc.mean(1, keepdim=True).detach() x_enc = x_enc - means stdev = torch.sqrt( torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5) x_enc /= stdev # embedding enc_out = self.enc_embedding(x_enc, None) # [B,T,C] # TimesNet for i in range(self.layer): enc_out = self.layer_norm(self.model[i](enc_out)) # porject back dec_out = self.projection(enc_out) # De-Normalization from Non-stationary Transformer dec_out = dec_out * \ (stdev[:, 0, :].unsqueeze(1).repeat( 1, self.pred_len + self.seq_len, 1)) dec_out = dec_out + \ (means[:, 0, :].unsqueeze(1).repeat( 1, self.pred_len + self.seq_len, 1)) return dec_out def classification(self, x_enc, x_mark_enc): # embedding enc_out = self.enc_embedding(x_enc, None) # [B,T,C] # TimesNet for i in range(self.layer): enc_out = self.layer_norm(self.model[i](enc_out)) # Output # the output transformer encoder/decoder embeddings don't include non-linearity output = self.act(enc_out) output = self.dropout(output) # zero-out padding embeddings output = output * x_mark_enc.unsqueeze(-1) # (batch_size, seq_length * d_model) output = output.reshape(output.shape[0], -1) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation( x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/Transformer.py000066400000000000000000000130051443355502200166630ustar00rootroot00000000000000import torch import torch.nn as nn import torch.nn.functional as F from layers.Transformer_EncDec import Decoder, DecoderLayer, Encoder, EncoderLayer, ConvLayer from layers.SelfAttention_Family import FullAttention, AttentionLayer from layers.Embed import DataEmbedding import numpy as np class Model(nn.Module): """ Vanilla Transformer with O(L^2) complexity Paper link: https://proceedings.neurips.cc/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf """ def __init__(self, configs): super(Model, self).__init__() self.task_name = configs.task_name self.pred_len = configs.pred_len self.output_attention = configs.output_attention # Embedding self.enc_embedding = DataEmbedding(configs.enc_in, configs.d_model, configs.embed, configs.freq, configs.dropout) # Encoder self.encoder = Encoder( [ EncoderLayer( AttentionLayer( FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=configs.output_attention), configs.d_model, configs.n_heads), configs.d_model, configs.d_ff, dropout=configs.dropout, activation=configs.activation ) for l in range(configs.e_layers) ], norm_layer=torch.nn.LayerNorm(configs.d_model) ) # Decoder if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': self.dec_embedding = DataEmbedding(configs.dec_in, configs.d_model, configs.embed, configs.freq, configs.dropout) self.decoder = Decoder( [ DecoderLayer( AttentionLayer( FullAttention(True, configs.factor, attention_dropout=configs.dropout, output_attention=False), configs.d_model, configs.n_heads), AttentionLayer( FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False), configs.d_model, configs.n_heads), configs.d_model, configs.d_ff, dropout=configs.dropout, activation=configs.activation, ) for l in range(configs.d_layers) ], norm_layer=torch.nn.LayerNorm(configs.d_model), projection=nn.Linear(configs.d_model, configs.c_out, bias=True) ) if self.task_name == 'imputation': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'anomaly_detection': self.projection = nn.Linear(configs.d_model, configs.c_out, bias=True) if self.task_name == 'classification': self.act = F.gelu self.dropout = nn.Dropout(configs.dropout) self.projection = nn.Linear(configs.d_model * configs.seq_len, configs.num_class) def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec): # Embedding enc_out = self.enc_embedding(x_enc, x_mark_enc) enc_out, attns = self.encoder(enc_out, attn_mask=None) dec_out = self.dec_embedding(x_dec, x_mark_dec) dec_out = self.decoder(dec_out, enc_out, x_mask=None, cross_mask=None) return dec_out def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask): # Embedding enc_out = self.enc_embedding(x_enc, x_mark_enc) enc_out, attns = self.encoder(enc_out, attn_mask=None) dec_out = self.projection(enc_out) return dec_out def anomaly_detection(self, x_enc): # Embedding enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None) dec_out = self.projection(enc_out) return dec_out def classification(self, x_enc, x_mark_enc): # Embedding enc_out = self.enc_embedding(x_enc, None) enc_out, attns = self.encoder(enc_out, attn_mask=None) # Output output = self.act(enc_out) # the output transformer encoder/decoder embeddings don't include non-linearity output = self.dropout(output) output = output * x_mark_enc.unsqueeze(-1) # zero-out padding embeddings output = output.reshape(output.shape[0], -1) # (batch_size, seq_length * d_model) output = self.projection(output) # (batch_size, num_classes) return output def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None): if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast': dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec) return dec_out[:, -self.pred_len:, :] # [B, L, D] if self.task_name == 'imputation': dec_out = self.imputation(x_enc, x_mark_enc, x_dec, x_mark_dec, mask) return dec_out # [B, L, D] if self.task_name == 'anomaly_detection': dec_out = self.anomaly_detection(x_enc) return dec_out # [B, L, D] if self.task_name == 'classification': dec_out = self.classification(x_enc, x_mark_enc) return dec_out # [B, N] return None library/models/__init__.py000066400000000000000000000000001443355502200161070ustar00rootroot00000000000000library/pic/000077500000000000000000000000001443355502200133005ustar00rootroot00000000000000library/pic/dataset.png000066400000000000000000004673731443355502200154570ustar00rootroot00000000000000‰PNG  IHDRÌ|=Ô aiCCPICC ProfileH‰•WXSÉž[RIhH ½‰"5€”Z©‚¨„$PbL*vtQÁµ‹(VtUDÑÕµ bwQì}± ¢¬‹*oBºúÊ÷Î÷Í?gÎü§dæÞtÚø2Y.ª @ž4_Ì“’Ê"=À6 ¾@!ãÄÆF(ýý?åí5h 岋ŠëÇñÿ*úB‘B’q†P!ȃ¸¼H “ç@ zëÉù2Cl ‡B<]…³Ôx© g¨ñÖ>›„8.Äõi|¾< íf¨g² ö#ˆ]¥B‰ˆb¾âˆ‡äåMTáÙ;@{Ä; fg|ÙõþŒ~>?k«óêrˆD!ËåOý?Kó¿%/WÙïÃ6šX§ÊÖðFÎÄH¦AÜ)͈ŽQÕâ÷¡ºî T±2"Qmš \X?À„ØUȉ„Øâ0int”FŸ‘) ãA W :E’ÏKÐÌ] R„Æk8×É'ÆÅôãL9—£™[×÷ùUÙ7+s9þb¯ŸÿM¡8!b*µ@’ ±6ÄŠœøHµ fU(æF÷ÛÈ•qªøm f‹¤áÁj~,-S§±—å)úóÅŠÅ^´—ç‹"ÔõÁv ø}ñA\+’rûyDŠ1Qý¹E!¡êܱ‘4Q“/vO–§™Û%ËÕØãdQn¸Jo±‰¢ ^3‘§š’åÇ&¨ãÄÓ³ù#cÕñà pA`%l`"È’–κNøK=ø@²€¸h4ý3’ûF¤ð Á_‰€b`^pߨ@ýç­úé2ûF úfä€ÇçH +ûfI¼%GP#ùÁ»Æš ›jìGj¢4e?/K§ß’J !FÈŽ¸ €ûáQð›ÎÆ}ú£ýjOxLh%< \%´nNÉ¿‹ehƒüašŒ3¾Í·ƒœžx0îÙ!3ÎÄM€ îýpð@èÙj¹š¸U¹³þMž|SsÅ•‚RQ‚(ßÏÔvÒö`QUôÛú¨cͨ*w`ä{ÿÜoê,„}ä÷–Øl?v ;†Áau€…Åê±óØaXCúÖP¿·¸¾xr ä|OU%®Õ®®Ÿ4c _4%_µÁ¸eSå’,q>‹¿"O*:„åæêæ€ê›¢~M½fö}+æÙ¯º¹–øOííí=ôUy€ý‡á6¿õUgß_g8½Z ”¨u¸êA€o¸£Œ9°0#7àü@#A H)`<¬³®g9˜ ¦ƒ9 ”‚¥`X 6‚-`Ø ö:p'Á9p\·áúiÏAx z!!t„#ˆ-⌸!l$ E¢8$IG²)¢D¦#s‘Rd9²ÙŒT!¿"‘cȤ¹‰ÜG:WÈGCi¨j†Ú¡ÃP6ÊA#Ñtš…NB Ñyèb´­Dw¡µè1ôzmCŸ£ÝÀ´0&f‰¹`lŒ‹Å`©X&&Çfb%XV‰Õ` 🾌µaØœˆ3pî×pžˆ ðIøL|¾ß×âÍøeü>Þ…!Ð ¦g‚/GCÈ"L&ÊÛ'ànj'¼%‰L¢=ÑîÆb6qqq=q±‘ØJ|Hì&‘HÆ$g’?)†Ä'å“ŠIkH»HGI—Hí¤÷d-²ÙFN%KÉEä2òNòò%òrE—bKñ¥ÄP„”©”%”­”ÊJ;¥‡ªGµ§úS¨ÙÔ9Ôrj õõõµ–––•–Öh-‰Öl­r­½Z§µîk} éÓœh\ZMI[LÛNk¤Ý¤½¦Óévô z*=Ÿ¾˜^E?N¿G¯ÍЪÍÓjÏҮЮվ¤ýB‡¢c«ÃѯS¨S¦³_ç‚N§.E×N—«Ëש[¡{P÷ºn·Co¸^Œ^žÞ"½zgôžê“ôíôCõ…úóô·è×ÈÀÖ .CÀ˜ËØÊ8Áh7 Øð ² J v´têz&N1¬0ÍòÏZ‘Õ!—‰;%\ÉZÉËìˆìÙïrbr¶çôæ&çîÉ#ç¥ç”êKs¤ÍÍ'N™Ø*s–ËÚ&ùNZ5©K)ߦ@ãõùðð~^é üIy¿   ¢àýä¤Éû§èM‘N9?Õiê©O à ™†OLkšn9}Îôû3836ÏDffÌlše=kÞ¬öÙá³wÌ¡ÎÉ™óG‘kÑò¢7s“ç6Ì3›7{Þߪ.Ö.–_Ÿï7ã|dAËB÷…k~)–œ-u--+ý´H°èìÏÃ.ÿ¹wqæâ–%^K6,%.•.½¶,pÙŽåzË —?\1jEíJÖÊ’•oVMXu¦Ì£lãjêjåê¶ò¨òú56k–®ù´V¼öjEpÅžu¦ë®{·^¸þÒ†  5Í6–nü¸I²éÆæð͵•v•e[ˆ[ ¶<Þš´õÔ/ì_ª¶™l+Ýöy»t{ÛŽ¸ÍUÞUU;Mw.©F«•Õ»Òv]ܲ»¾Æ¥fóæžÒ½`¯rï³_Ó½¶/r_Ó~öþšßl[w€q ¤©ZÛU'®k«O©o=8ò`Sƒ_Ã߇þ¾ý塊Ƈ—¡™w¤÷háÑîFYc籬c›&4Ý>>æø•æÑÍ-'"Oœ>vòø)Ω£§ýO:ã{æàYöÙºs^çjÏ{ž?ð‡çZ¼Zj/x_¨¿ès±¡uDë‘K—Ž]¹|ò ïʹ«ÑW[¯%^»q=ízÛ á§7so¾¼Up«çöì;„;%wuï–Ý3½Wù§ãŸ{Ú¼Úß¹þAüƒÛŸ?R<úÔ>ï1ýqÙ‹'UOÝžêë¸ølì³öç²ç=Åéýµî…Ëßþúû|ט®ö—ò—½¯½6~½ýÇ›¦îØî{oóÞö¼+yoü~Çö‡S“?>é™ü‰ô©ü³ãç†/‘_îôæõöÊør~ßQƒ ÍÌàÕvè)0à‚:V}çëD}OíCà?aõ½°O¼¨ê¸Îm`/lv³!7ìUGõ„ €º»4(2ÝÝÔ\4xã!¼ïí}m©€ÏòÞÞžõ½½Ÿá» @ã$õ]S%Dx7ؤºë‚›+ÆÍ߉úúMŽß÷@ø¾ÿ{8Š¡©)@ŠeXIfMM*>F(‡iN’†x Ì ASCIIScreenshotì¿[ pHYs%%IR$ð×iTXtXML:com.adobe.xmp 1996 Screenshot 516 8ÜV—iDOT(NÞ~˜¥!@IDATxì¼,5ù¿ƒ€JïH“*Ò”K“Žt”&rA@Ž "M:‚"(àéEº¥ ÁK¹ôré]¤‹‚Îÿ}Â?óËÌÎîÙÝ™mç|óùœ3³³™LæÉl&É7 NAD@D@D@D@D@D@D@D@D@D@D@D@D@D@F‰$˜°×튀ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€xÌõ ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ŒHÌGd±ë¦E@D@D@D@D@D@D@D@D@D@D@D@D@D@$˜ë‘$˜Èb×M‹€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€H0×3 " " " " " " " " " " " " " "0" H0‘Å®›hY0î¹ç܇~(r" " " " " " " " " " " " " " "Ð3ŸýìgÝœsÎYêú- æÛn»­{üñÇK]T'‹€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@ ,°€3fL™$\Ë‚ùK,áÆWê¢:YD@D@D@D@D@D@D@D@D@D@D@D@D@D@Ê@»¾÷Þ{Ë$!Á¼=," " " " " " " " " " " " " "Ð=Ì7ÝtS÷È#ôä†uQ€ÀB -ä.¾øâR0ZvÉþàƒº÷Þ{¯ÔEu²ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€”!0å”SºE]´L­»d/u5," " " " " " " " " " " " " " }B e ó>É·²!" " " " " " " " " " " " " " ¥H0/…O'‹€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ * æƒZrÊ·ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@)ÌKáÓÉ" " " " " " " " " " " " " " ƒJ@‚ù –œò-" " " " " " " " " " " " " "PŠ€óRøt²ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆÀ `>¨%§|‹€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€”" Á¼>," " " " " " " " " " " " " "0¨$˜jÉ)ß" " " " " " " " " " " " " " ¥H0/…O'‹€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ * æƒZrÊ·ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@)ÌKáÓÉ" " À=÷ÜãÞ}÷]·ôÒK»)¦˜"ÖVD@D@D@D@D`@ÜvÛmîÿûŸ[e•UÜDM4 ¹V6E@D@D@ºE€±?Ƨžzj7jÔ¨n]V׎`Þqĺ€ˆ€Œ ßþö·Ýc=æ.¹ä7ß|óŒ›Ö]Š€ˆ€ˆ€ˆ€ˆÀ0"°Ì2˸ÿüç?îÞ{ïuŸúÔ§†ÑéVD@D@D@ª ðÈ#¸Ñ£G»EYÄsÎ9U$©4D@D /H0ï‹bP&D@D`ð |å+_q÷ÝwŸ{ðÁ}£yðïHw " " " " #‹Àg?ûY÷ïÿÛ}üñÇnâ‰'Y7¯»’ÀßÿþwoYŽ‡É±cÇ_D@D`PH0”’R>E@D Ï H0ïóRöD@D@D@D@D`̇¤¯E@D@D`„`>Âݾ ċqáêÖD@D ›$˜w“¶®%" " " " Õ`^=S¥(" " É€óáTšº˜€ó˜†öE@D@Ú& Á¼mt:QD@D@D@D@ú‚€ó¾(eBD@D@ú–€ó¾-eLD $ æ%êôrXí_ÿúW¹D†8{Ê)§tM4ѱº÷õûï¿ï×y¾ûî»Ý½÷ÞëöÞ{o‡Ð¨ ƒN W‚9k,þç?ÿi ßä“O®5["öIä·Þz˯Ouûí·»×^{ÍvÚim¤¢SŠèÝPDEÇD@D@D@ºM@‚y·‰ëzƒ@àÿûŸ£½Þ(L6Ùdn’I&i¥©ï’$qï½÷^øŸúÔ§ÜSLÑ0N¿ù /¸SN9ŽòÊ+n‘EqßùÎwÜL3ÍÔïÙVþD@Œ@¿ 毾úª7nœ{ôÑGc…ÓN;­›yæ™}3ß|ó¥úÀã?î.½ôR·å–[º9昣¯Ët¸Ö•|ðûïÿÛ4{Þ¯¼g:K@ã¾ÎI0ïì3¦Ô‡ €h|à«ÜקŸ~º›k®¹Ê%Ròl^Ä4&ø?~¼ãŽØôú믻+®¸Â­½öÚ%¯ ÓE ÷z%˜3Æ]xá…-˜tÒIÝ4ÓL㦟~z߀žqÆÝòË/ïFå|Pø?&Lð"ùßþö7_½üòËŽ¿Ï|æ3Ž†»BûônhŸÎè  æáªT›Ào~ó/®4º‹­¶ÚÊ‹/â4óÝwÜá;ì°†Qg›m6wÖYg5ŒÓï_î¶Ûnî‚ .pˆ&3Ì0ƒÛsÏ=½AI¿ç[ùè?Á‘zúü£{ã7Ü?ÿùO/Æ2n…ÈÊØßÜsÏí–[n9÷¥/}É}öÙîúë¯wgžy¦[k­µúºH‡k]¹ï¾ûúÉ ÍÂ_rÉ%ÝQGÕltÅk€Æ}³°$˜gyèS— o´ÑF½*"u¯-¸×]w]÷ÔSO¥/mf ‡píµ×ºuÖY'|ÔV–@¯óÛn»Í]wÝu^Ľá†ü¶D¼M„ßߧ?ýi/úÒ€f`pÖYgu -´[c5ÜlচjªzÉŒ¨ã üŒ;ÖOòyûí·S~ŸûÜç¼5Àˆ‚QñÍêÝP1P%'" " "Pš€óÒ•À0$@ó¦›nrÏ>û¬dÞ}÷Ýš»dòõ_þòßǬù²…XZŸ{î¹…g,¶Øb^ðYxá…Ý®»îZgPÎ;ï¼î駟N³»ì²Ëº;ï¼3ý¬þ%ÐOæÏ<óŒûÁ~àÇ­0î 0 ‡: æ'žx½óÎ;¾nže–YÜtÓMç8'ˆì;ì°Cÿ‚¶œ ׺’÷Ü]wÝå0ÎÁ ²(`ì´úê«»\Ð-½ôÒnóÍ7/Š¦c% hÜ7 P‚y–‡>u™³IG^uꩧöbÕ<óÌãp¥Î.7Áþð‡?¤ñØáÇL‡·î¸«â—à7Þ˜q_E‡…d½ ×\sÏÂÞ©§žšÉŠó }`½Ì™‘Ž‹‹Œa19Èa½õÖËŒóáy‘‰ " ýO _s–gÜvÛm}ÝûÑGy—ë|ÞtÓM}ÉXã…=ö˜;ñÄÝ“O>™û“ŸüÄzè¡™cýöa¸Ö•” xàå݆‹ü|8üðÃý;•I¼÷øS¨ž€Æ}sLÍÒNAzFà·¿ý-¦ÖþÏĶÄăä‘GI^|ñÅÄ*ÌÄ\¨$6ã+9øàƒÓx!þgœá¿#q9硇J®¾úêÄf¥ñM@ïÙý… ÛŒ¶Ä^â‰Í`KÌŠ5Í÷b‚yˆ¦­ 4/ùËþÙ~ðÁ{vüÖ¬aœùñ;;î¸ãk(û|Ù:F¾î°™§‰5òê[3-sŽ¹kOöÞ{#=X§#ùðÃk¼f™`>ÒÑ”¾½J#T" " " 0ïK¾ÍgÓ+NYɉÀð `¶“Å_<Ó7 ãT«­¶ZB¿Ý`K¦Kú§vZ»É¶uãl&`·un3'Ýzë­Éú믟Ì9çœÉšk®™˜I3§)Žˆ@¸÷Þ{}]eV¿=͹aOÌØ.­77Ûl³Ä<¼¦ã!s&Ì&Ô9o¼qbž'ÓøßûÞ÷B”¾ÝŽ„ºÒÜã§eÞ§&’{½§o f3Vï½®qßlaÊÂÜ~… ½#ð«_ýÊ»‘šbŠ)Ü%—\â× )Z?˜™Fûí·_&£çŸ~¡+뜸Ë.»Ì¯ÅL3ÐÝ7¾ñ̹½ü€U<3ñB…y ¡í è•…yžÛAäŽ8âˆÌaÖwÛzë­3ÇÂ,Ô±2Çõ–Ô!0cŸµÑ±NWpîá‡v¸þ AæD5[½ªá¨TD@D@D@Ê…y9~:{d`iA–Ì<”±.îŠ+®˜ÿjÈÏo¾ù¦_Nð¹çž+ŒÛMï‰Xeââø¥—^òcu…*yÐ&§§KN;í´~y4Üï*ˆ€ô?~±0ÇóÆŸÿüçX£zÒ$1oi~ÀxÝ€“X"•qù~#¡®|á…¼·Ï¸¾øÅ/:3ªŒi¿fÞë÷ý°óšN-O—Çûì³´Ì霅VsÎÇ53.•Y —XßúÖ·Š’íɱå—_Þýõ¯M¯-Á0¹æ˜cŽq¸cŠuŽ:ê¨øЈÝüñÇýºA€ó@¢š­Þ ÕpT*" " " åH0/ÇOg ,È’UEÁ,ýÄë¢ï;ýôÓÝŽ;îèup?kÞ3Ñxà·è¢‹fŽuêÎÍãš[`´®x§ +]`ý ˜#$Ï<óÌ~¹Œ€’¥3¦šjªð±p;~üx¯<úè£Î¼…¸û0žvåfž>3dÍò±cÇfŽéCûšy¯kÜ÷¾ÌÛÎtfX‹Ê\¨¸vØ¡nŠ­ æ$tÈ!‡øuH~÷»ßùõÎë&Þå/VXaÇŒ·$˜Ú:~ÌÍýºûá˜Á9”`Nd[ÒÁ™köÌyÌV5÷G™c#õƒN-y½:ËW©‹€ˆ€ˆ€4G@‚ysœkd` sŸg˜a‡e8"wXKcñØŠ¸Íî¯~õ«Þá¼óÎëæ™gwà 7„$ý–þê—¾ô¥Ì±N|Àðïk¬õ»ì²ËJ0ïd¥)N sÖ%_h¡…2õïý÷ßï[l±†t©¯ÇŒãÌ»›qÆ3ž&ž¨/;FÃGs­ŸI¹å–Ëè'™/õ¡%;×5îû V æ-=^Š\53Ï<ÓwÞyÎÖvsÏ=wÝäÛÌÿö·¿¹ý÷ßßýô§?uK.¹dÝ´»ý…D‘n×õºE`Ðs[§ÛÏhd°"YQΩáô,:±§wC'¨*MV H0o•˜âDA0_f™eœ­‡ë½ÆvÛm7wÒI'ŇîÛZánà 7tôE;ì0¿˃š‚ùóÏ?ï—7 .Ž%˜Ç% }@ s¼n`!‡-¶ØÂOfšd’IâÃ5ûxðøò—¿ì—Àºy²É&«‰£Ý# Á¼s¬[y¯kÜ÷“r`Þ¹çQ)7Aàå—_v¯½öš_·ÑˬÁü_ÿú—xæŸ~Ç:R!¼õÖ[Žµ1^|ñE÷üÃÍ2Ë,î _ø‚_+£QÂùaËË•µ4Þxã ÇysÍ5—ÿcFÂk±úÓŸÑÓíP¢çâV¦QÀ½LÑZïíæ©Ñµô4K`Ðó·ß~Û±n9뺄ÐΚ9Ô+&LpÏ<óŒ¯æ›o>‡•Àg>ó™lÃ-³]©[hüó›ßLëê´»ï¾Û½úê«ŽµÝHyͦ.úñÇ»gŸ}Ö¯G^™Q;묳úôê-‹Á¹C5œ¨WqiEš¤ƒUyl¶ãÁù¸[Â59õr¬á ÊMÔé .¸`ø:³å}š;¬EO½L<òPTgNŒ>TõŽà ¼X„úšre"Ï–(XÄï&½¢BЮˆ€ˆ€ˆ@ÏH0ïz]x€Á|µÕVs[o½uWC&^Ó˜sÎ9›º«õ×_ß]}õÕ¾Ÿ€Åceóvú¤ôY·œ|Ðg$`|rã7¦÷@?4îä_ØN«ýŸp.ýoú{¬—¾îºë†ÃCnÛí×Æ k -¦¡}hž@?æÔs3Í4SÆÂ|ꩧvtÛsÏ=ý˜P£;Ú}÷ÝÝïÿ{ïÙ#ƒjtN;ukœ^»õ$i´SW–Í/×íF=Ù+Á¼,ŸNß2ÆùÔSOù÷#“óЯøÓM3¡Õ÷z§Ç}›És?Ä‘`Þ¥ < I Á<ŸèÓO?ípÏÎúáTÄï½÷ž¶iìóBEˆÙf›mÜÆoœ?5ó™FùÉ'Ÿì®¿þz/–#b!† bó‡pŽˆ¾ùæ›®>”(‚µ=ë®7 £Göy qÊæ)¤£­”!0è‚ùM7ÝäV_}õ ÄΡ~á:ù§žzª{â‰'üJï¾û®¯¨[Xƒn¥•Vr»îº«›bŠ)Â)é64²p“sûí·;\KÑpC@æüË/¿ÜáVñøƒ>HÓE>øàƒ}ƒ)M¬ÎuuàŸþô'ï6Y´LÐaP”<Í6Ûlîßø†¯‹Ö|ª×pBÀÿå/éî¸ã‡ØLšO<±¯W©<ðÀW÷!‹ÜIX0À´X¢V|÷ë_ÿÚ»`‚Öß4 ×Xc ÇúòA§ÈšwÞy§¿7ò@c’¸0ÂÓÈP *Þ”9Knüñt÷Þ{¯Ÿ†K0Þ9‡z¨ÿæL¢8ÿüóÓ z7„§B[^`ÞKúºö ˆóK.¹Äá:–ÉÃqÀRáf¨Àú¹ôè'|ÿûßw§œrŠçÁ¼Ý>)ý1òK_†¾TôEYG6&%#0ѼLÿ‡~óm·Ýæÿاό¥ýP¡l¿–ô5†6e}/ ôƒ`Ž€ÌxËGÄáóŸÿ¼¯C‹b¼¿^@ˆÄúO´}…vëVÒ,SOr~;ue™ürMB7ëÉn æeøtcüSÆ€Yš…qVø0ÆÉX-Ï4Ï8nxþÐãçœ÷6ïêvÞë÷ýäi°ÿVÈ "Ð÷Lì`A¨ÌŸ MçûÜsÏMV\qÅÄfž%& %¶Sr '$&N'&l'&x'Vñ$fMšœx≉½t Ó6Á&1q*™}öÙ³êLl½“Ä\Ê'äåG?úQb”Oß*¦äÈ#,Lì'3÷ak˜gâ™›-ŸÞ /œ‰Çy&¸$§vZb{zNyJÓŽ” `îŒü3ûàƒ–H¥ü©Ç{læ·CÝa † › ›¬ºêª™ó¨L,ox_ZÃ%ášÖÈNÌÃDbk(%k®¹fbhbŸ&õ‹Yq'f}Xc>“¦‰«¾2‹ãĬ²³ÈNóaBpbKKø4M„N‡úÐ*òß(Ü|ó͉‰ÿ‰Y8$ÖH¾öµ¯%;ï¼sb®“Pnf-˜ˆ›l·Ýv‰Í ­IÎDüÌõÍj"¡¾Zo½õ³RÏ|òG=IÝebt&=³´Nl)±!_ïRw†sþð‡?$68äËÃ,±Óãá{¶3ÏÍ÷+¯¼’lµÕV‰5ZÓcܼÍZ#Í†Þ ) 툀ˆ€ˆ€ôí7Ú*6PÚÃ\èÒ"ÐßÌØÂÿNÌÂÜg´¨:÷ÜsÙOãd›TíÓ¢Ÿf“m}zßþö·3}~“ô½ê…²}ÒcŽ9Æ÷cBÿ•ëñGßÔÖMOÿYd‘Ä&^'íö®¸â ?ÞµÃ;ø~¢ ôû±5®ÅxÜP¡Š~­ÆІ¢¬ïE`hf àë›P3täÆ`\(ÔWñÖ¼G&f—˜àXwŒ¿™l•©[Û­''bŒ­¡Õº²L~cÝ®'m"TM9ÚD´8K•ì—åÓñ[³*O6Ùd?†Ì8ð¦›nšØ仄vAW¤½`J‰-Iàõ.Ú"á/Œ9·ú^p•ã¾•XÁm…‚ô=2‚¹ÍMÌ…oZñ">Ùì¬Äfèx¡‹Ê`ƒ 6H¿ŸcŽ9›á[È„—B /ávÚÉ‹@æ>=áÏ\¼'f½™˜Å£ÿžÊ¬( %Š Ö#8šµ§O‡—üG‘СÒä%òßÿþ7MºŠ<¥‰iGJÂë æüÞlV»ŸD~»¡‘Ídš"á8FÄ@âüãÄf÷%³ˆ¦Ô9 tð›½è¢‹2õq¨o¨3B@ð¥!oÐi=ò@# !˜É>æž.m,‡ïÙÒ€2 ï\Í–üP6Ü4q©ãÌ5x‚ oí‰ÍæO¯èO=™ù†ƒ©ˆõ¿L"27‚É.»ìâÅë8L8à€2É™5ºŸ$€¸ÇeŸ:ÒfIzžÐæ&+1kòd±ÅËÄEüçÝÀ¸"¾S/S4$ã ä!¾(TñŽ`Òyæ^ó÷³Ç{ø‰T±ˆâðÎAï†@B[^`ÞKúºö È ææN<à m}&`›²†·dËR%LDæœ6Ú(A¤ ´"˜WÑ'¥¯gÞóî˜éÏ`ÈÁñøï£>ò“¦Ûéÿ˜Ë÷þcà¶C æUõk5†Öð‘Ô—"Ð~Ì1PÈ¥„:…10E Üûj5”­[ËŒÙÒ-וeóóév=Ù Á¼ >¿eB7â<Ç:™÷š„çœ÷´y I¿ Ïy~Ký"[&,±åÀ2×j$˜WÙ¯û¾íŽë1Ñ1IúE0‡¹-óç­lãº+ÞgL/‹ŒÆÆ+C•WÙºµÝz’q"sßr]Y6¿1nדÝÌ«àÓÉñ[ø£aÄÄóËØt°eÃx®-Ý’yw¢]pÁ^?BCŠ>;×9‡±Ôø·Ã~»ã¾qm_‚ù •ØÍoÁ|‰%–ÈüØm-àŠ&LÈÄaX>ðR ÖåTEép®†™IŒUaQh$ŠØÊ .G¨ìx™Ó™hô2¯*OEùÔ1h•@? æÌÚŸo¾ùÒ?¬“±Ü³öBƒ€Ù§¸ç¦q:Txûí·S«g¬‡ónÇÃùˆÃ¸š ×`‹ûõ|Àš ïVœ¬Õ™ f×ÇéaåM3aÐ†Æ qŒcÑ:Ž{饗fÒƒK^XÏ7œ¬™XoÀ‘.§p]®MÜz|°¤ˆï…ºoܸq “ ‰Ïć8..™aYä =ŽË3PªzG6“âk²OYÃŽÀ@õü˜1cü6®ßõnðˆôOD@D@D Ç$˜÷¸tù ÌÉ´­ý™ºK }Ævê-óEÿ +mâÒˆ¹›̫2°Î=·Ûÿ¡¯zÎ9çdúNõó*ûµC£ÔD <~Ì©#‹g)>ÆãCýo“bLƒÆŠ† UÖ­íÖ“ä±Ùº²Êüö¢žì´`^%Ê¥êñ[Òdr]àý+xC<ŽC³‚yÕ}ÒVÖÉo™þKƒÅ¬ê æUök5†?eÚö ô“`Î]0¾òðÃû%X`LÝ×3è, Á|£PeÝZ¦ž$ÍÔ•Uç·ÛZC§ó*ù„ç&?æYfü–4y~cîõ<¼0ÖÉ3?×guVÈVͶ•÷z§Æ}k2Õç$˜÷y){Ÿ(#˜ãÒwï½÷NFí­úšP1Û{î¹'SÑ5ÔéüàÆ%TH $°¦0O^øÀ}r=q*/ŠP¡b!ÉÌbĪ}öÙǯ±ç¯Þ~Uyª—¾Ž‹@+úY0G„eÆ)®š°ÎÆ…8.ÐÆYS íðÛfæ).Ä7Ûl³ŒËì< ê”pkƒ¯¶Újuÿ‚îŸmìr/¤=ÿüó§i‡<× ÌŽÓË×9x¹ß3a€FU£@ãŒNÕW^™<õÔS5Qó §zÛáÄ•W^9½>ù¨gY‘·ÿÙÏ~’¨Ùâº/Ü[f\6 yîEëVUõŽ ¼_âü±ŸwÓ_/¿z7Ô#£ã" " " Ý$ Á¼›´u­A%P$˜s/Œ-…ßPè0‰7ß÷Ã8b¥•Vò}Æ‚Þ|óÍ Šfóªû¤­ ¬“á2ýŸ»îº+Ów*‡ãUök5†Q(O ßópGT 0ï´ÓN âx¨‡ó[ê]\´× UÖ­eêIò×L]Ye~{QOvZ0¯’Oxfª¿%Íüû—1ßz!¿$cÛõB>ÝzB<çwjÜ·^Þúõ¸ó~-å+C Œ`NGä…^ð–åTÀ!àšøºë®óëSYÄ/Ïz•Ò¶Ûn›‰‡ÈÆÚÁ?øÁ2–ëX ó\;/Š0Ûx®¹æòéâ¸Èê4ä¹h[EžŠÒÕ1h•@? æ¬U“Lt kic¹Œµr\0бÎ:ëºû&-¬ÔCüÙf›Í×ÔÍþ-ëÐJƒ ±8\ŸíwÜ‘¹ÅxV-õN3z‹ÆqQhµá”_“.o5®ÑŠ`Î=Æ÷<”`žŸñ‰{û|¨òQÔªç?Ÿ½òDôYD@D@D ‚ØW¯MØ‹<éš"Ðoê æLRfBvÜgaŸcq`ù=–—⻣>:þÊï7+˜WÝ'me`Œ–éÿ4#qªûµCƒª‚”#Я‚9wÅXaÏ;ï¼$?Þ×ÍŒýcy\ª¬[ËÔ“ä­™º²ÊürÍnדÌ«æ£*ÇoI‰uñóÉ„üR•Ä#œp ™¸çŸþ'_üoå½Þ©qß‚lõõ¡‰È†‚ô5ë@¸ýöÛ/“G« Üæ›ož9Ö̇×^{Í]uÕUάÀ­½ëÞyçg¢‹»æškÒÓí¥éžxâ‰ôsØ?~¼¿&Û8ØúÅ> [#Øm½õÖnši¦‰¿Î쯰 Î,\ÓcfUîl0Â6wÐÎ,<­á›~?ÔNyêú^š!ð•¯|ÅÙRÎÖçñ¿‡fÎéDœãŽ;Îýð‡?Ì$m‚¹3×Û™cñs‘íÌêÜ™ =÷ú믧_Ù€¡3¯îðÃO±c9ÇïÞÄV|Ï=÷tf‘ž‰3Ô[›Æ™•v&š dê³0wæî='|0aÞ³ŸMLv&ºú&ÒúzÈ\ÿùÏænÝÙ:å!j[[[ÎÂÙ,Üô\òþÊ+¯¤Ÿó;6(äëÚpÜs·å–[†évÇwt§vZúÙ,Ì=óô@´cëò¤÷Èaênž·zÁ°¾žß[§ÎÙĤð±p[æo[»=“.eaV%™cEôn(¢¢c" " " Ý&@»ÅD?ßG5wÑݾ¼®'A€~£¹@uæeÌÙ w&Ï|^sÍ51PJO5ÕT¾¿9jÔ(Œ~‘‰9næ™gv¶ž®³Áü4.;Œu™Ëö̱‡zÈ}éK_Ju¢Oj½ÜZk­•^ÃÄ&gžÌÒÏù2ýŸ±cÇ:ÒÁ,ÌÝ#<>úm'úµCË Öh‹õõ™¹†vü–û1˜Øèø½›±Š;õÔSÌÔdsá…v7ß|³¯‹Ã—U×­eêIò4T]Yu~¹f·ëIs[列rJ.†å–[.£Ÿ¤_´¸Ó >d¡ªñÛp;ù1Wó~êÌ+±3ïÆ!Jº=ýôÓ¥ŸÍs¦[tÑEÓÏñN+ïõ|ª÷ó3û}-ç+s"ðÿ ”±0YWØ„´dõÕWOL¨òÖ¡¸?ÇÊWÆöƒMÿêY˜3Ëþ¦›nJ¬JãÆçÍ1ÇÉÆoìÝ>‡ëæ·y+Âø|öY‡Â„üüiu?W‘§º‰ë hÀ Y˜ço k€Ýwß½æ·ÍLÄü¬¾ &dâxàùäÚúÜÊ Å|=[˜?÷Üs™üÙ$œ¶òŸÔêLÃõ×_?“‡*,Ìq§×™CY˜S—Çñ™]/TñŽ(3sXï†z%£ã" " " Ý$ ónÒÖµ•@= sî‡õjm2l¦BŸä{ßûž¿]N¦›n:ÿýn»íV³Ä‘š±0ïDŸ´K4òY¦ÿÓŒÕd'úµC£äD ~¶0ÏßÙË/¿ì-ÉçœsΚz™5£ÑâPuÝZ¦ž$_CÕ•Uç—kv»ž4Q»¦lL0'+¥C'ø©ªÆoà âÒ Ñ2ðNƒWÌ|0#±4ÞÜsÏíÛù8ás+ïõNû†¼ ÊV.Ù¥¤Fx>Ë æI¸f]bÖ'Þpà ÖÇý9BI,ªÔÌ)›æ×@¦³âsͺ0Yj©¥’ßÿþ÷…¥–EX_Ý,ËÓëÛ,~/º›å{áùEËæ©(MV º`Îýšsú[ ¿kê Ö¢‹ƒÍ|ÏÄc¢L¡ªW>,ûP6tªáÔŠKöN æU½#Êt„ôn(û„ê|*„>.ƒ¥ " Å æœ{ÔП Ûf˜ÁGpÀþ;Ü­š_ášÌó}¾*ú¤­ ¬“ñ2ýŸ¡D ÒÏßcýZÒÕD }½Ìßzë­äŠ+®HÌ[dS7iÞf³˜­©›qÛ‡|½S¶n-SO’¯¡êʪóXt³žì¤`Þ)>UßÞlÍëpb–öé3:õÔS'ÇsLfbF–aùIó åÛqùýVÞë÷Íç©ß?K0ï÷Rþ<2‚ù­·Þš°6¸¹>÷/:se•Y§·Áœ ±ÊÓO?Œ3Æ[„‡P¼]h¡…jD6ÎÍ‹"¼àùË_&åá|Ö²Úwß}3"ç6 eòÔ(]}'Í‚y¾.¿É¼u4ñÒÃ÷³Ì2Kòî»ï6‹ªn¼ª\ùü1‘çÕW_­{Ýf¾èTéׂy•ïˆ2!½šy GD@D@D Ó$˜wš°Ò†ÌÍõo‚7¬Ð_ [[Ž* VŽ¶¤Ÿn‹x4#˜çû|UôI[X'ßeú?C‰@¤Ÿ¿Ç*úµ¤KÐÚ'ô_Ú!ÐkÁüÊ+¯Ll‰ ¿Ny³ùÇ«äÉ'Ÿ\S/#J"‡¯wÊÖ­eêIò4T]Yu~¶Ýª'«Ì™ôyà 7$X—wŠOUã·1oŒ'õ«_%³Î:kúœÎ6ÛlÉN;픜qÆÉ)§œ’àA϶LhrÄG$°kZy¯wjÜ·Qþúñ; æýX*ÊS vó7ß|3YqÅÓJÆÖ‡òbyþTž¡öÈÂœÊö²Ë.K˜Å®¶la_Aa½§Áþ^{í¢¦Û¼(‚¥;ù´5°2çÏ4ÓL‰­‰•žW´SUžŠÒÖ1h•ÀpÌ~øáÌï0ü¦iŒÇßá{Ä󫯾:ŽÒpßÖ{J¶Øb‹äùçŸÏÄ«ªÁ…猸E>™•Øl`é‰Ûo¿=½S §^ æU¾#€U¦#¤wCæqÓ`Þ#ðºì@‚y£¥¯N<ñÄ´¿úÓO?½ŸxÁwë…fóNôI[X'ïeú?C‰@¤_u¿VchPUòz-˜c-N½jë¨7tG¿SÆ€òceŒçÅ¢cÕuk™z’üUWVß^Ô“U æ¼Ë_|ñÄÖ®÷“ý<~›FÑ.¿üòLûaª©¦òVåxYaÙP\µçµ×^ËŸ^ó¹•÷z§Æ}k2Õç$˜÷y){ŸhW0GäštÒIÓJfÍ5×,´Ú~ã7Ò8¼p‹sÜ·`5ŽÀ¯¿þº?Ž%{è±-Z_·H!½'žx"YrÉ%3ç“\D× Uå©^ú:.­‚ùï~÷»Ìoß1çgžy¦Eþ÷ºÚj«%ü&‡ XPÑЉ'àp^U‚9i­´ÒJ™{a]›—^z‰¯†|Ð{åøÉO~’‰×©†S/ó*ßÀ*ÓÒ»!ó¸éƒˆ€ˆ€ˆ@H0ïx]v l¾ù澯ÕhÕW^y%™cŽ92}²0^´òÊ+7t%ÜŒ`°ªû¤ùõ¥—^ºa¹”éÿ %… WÙ¯ÕZ ª­”#ÐkÁ<»0æÏ8^+!¿NôSL‘±0'­*ëÖ2õ$yi¦®¬2¿½¨'«Ìñ$°Ækøw/^} Uòñ Ú¿*ÇoCšl'þþ÷¿ïóO[ã’K.ñ•X—Ÿ}öÙÉ-·ÜâAy®š ­¼×;5îÛL>û)Žó~* å¥.C=´¦“‘w‘\tò~ô£Ìyßüæ7‹¢%ù aÞyç­‰‡59›Ýwß½æ;à¾q;žµÄ Ü—Ä¡ž(Bœo¼1s>×ÃB>o…Ò«*O!=mE  ~̱¤aÛLšFuD8'l¶c÷LQ^èe)…£>ºæ7â³E,§áÃ@äAT·Ê×þû„,!¸©žzê©díµ×NXçÏþs&Z¾žÄcG£°Þzëe®Oî(ä9þìg?+ŠæU½†y•ï2X¦#¤wCÝb×" " " ]$ Á¼‹°u©%ðo|Ã÷uŠŒ$â›Ê÷ÉBó /Œ£ÕìõKxàšxù¾TÙ>).lCÙb4Ò(”éÿÜyç™k}ñ‹_,¼Tža™~­ÆÐ ë ´L ×‚9¿e–h žÂ5;ëT7°Ðë¹e–Y¦æÔ*ëÖ2õ$k¦®¬2¿½¨'ß~ûíL™P>_ýêWkÊ¥™,{;ùä“'L„ÀÀ‘P%Ÿ‡*ÇoCšˆåx žfši’­¶ÚÊëUŒG3‰wíÍi…´Â¶•÷z§Æ}C^e+Á|PJj„çsï½÷®©8YÓa¨°õÖ[gÎÃÂÁ*¸9øàƒ3ñpÏ’á…1Ï<óøõ/òßóq—‰Ã$\÷wê›h€ýéOò–ït:¶ÝvÛäÃ? _û-–çñõXç©Q3:Ã9¬·S¶Ûn»Lºsî1¤Ç¶ÈH|<Ï{î¹'þ:©òAÂ0‹óÇ> ÿf‚Þ ÍPRN`ÞiÂJ8Öj,¥W4¹:Ü#’§›nºLq'?.â‡íꫯž9‡~ÅwܾN·U÷Ié/Åýú®Œ;…@¿ù駟Kõ°’‹¯Åx]Q`¿ª~­ÆЊë˜´N ×‚9ãïÔÔ!Œ¡¯»îºÉ«¯¾:ä0Æ{¢åü_üâ5çUY·–'"cÍÔ•Uæ·õ$ã£ñû€ý¢‰ 5@g<–ñVÎÇ;I0b¬’O¸d~¼±ÌømHs¿ýöK¦œrJŸ–¨"´ò^ïÔ¸o÷ÑÍ4$˜w“¶®Õ6µÖZ«¦âÜe—]†LŠ&®pŸwÜqÇ×-&LH¨|kò³ËŒn¾ùæäÑGM×ý / Öš¢®6ÝtÓôš»í¶[M´ *†|å-_YO=¬‡â0+Šû}÷Ýw3éU•§L¢ú mÏ6/Ø^†o}ë[éo0ü†¶ß~ûÂ,Ñp½í¶Û’½öÚ+a°#Ä[\á±dCQ@pþÎw¾Ssy\®ãÒ—9Çw\²óÎ;'¸³ã·<í´Ó&\pAÚp iÓ˦ä×q¨ O¶øÃÂ×~Ëzo‡rH&ñ¨ßàÁœûfÆþèÑ£“Å[,¡Ž¤”ÈÖØ‹¯G]¯ó”µE¿žž·ž8ì°ÃòI¥ŸY'>N¨fœqÆLüK/½4M‹*ߤ‡õ~œ?ö›é~?á|½ ª " " "ÐmÌ»M\×4Ï>ûlÂDdÚíôŸ-£GŸ,oÙFÿ°QÀ‚¬È•ûi§VsZÕ}Ò^x!ÓŸAˆ “Ï™Œ‡®UW]5µr+Óÿ¹è¢‹2ת׷«²_«1´šGHD -½ÌÉ4Ë"†ñƹ06+òÄnõž« ç°]gu’—_~9DI·UÖ­eêI2ÔL]Ye~{QO^ýõ™r¡lfŸ}ö¦ P˜€Ær‹0Æ“«bí¦J>”IÕã·¤É}àÉ3<ŸXØcäóÃþÐíâM#KÚxðÄU;éБ…VÞë÷m”¿~üN‚y?–Šò”@ŒÁõz^¢ò x’·‚LO¶›nºÉw`BeëH,ù˜i´ð {‹J•ãq<Ä \ärBxag¶Ùfó•TÞÂÛ,³ÌâÓÁ5Çøñãý¹ü£2Åpþ:r|ðAÖ3ÇUœ ÎÑ ÷\6O™‹êƒ”$¿^ æü/»ì²Bá›ß%â(‹Ÿÿüç^ÌÞc=’ 7Ü0aý¢¼P°•5“k…ûî»Ï×#ño•},Óà™ÙH#/ ¨îo~ó›B¡™""tœÖòE‚0 æ|\\½#¤ÇáÅ_Ìx½ˆÓfðƒzQ9 Œ2C’ÉBafH‹Æ%ËQÄç³Ï½äãr,î5Žÿµ¯}-yóÍ7C’~ûÜsÏy>q<\Âs½|àžâ¸0¸øâ‹óQýç¢úŸÁª¸Þ.ŠÓî;‚zü¨£ŽÊä¼î¹çž5“â ëÝÓоˆ€ˆ€ˆ@¯ „v!žØD@þý²ûï¿? ë—‡~ žµÆŽ[ØoãlúŒÁ3Þ _zé¥ÿK4·‡ sÄGÔŒcq­e—]Ö! Ç¡Ê>)}®üX^½·Â…%é'âÝþyǃb~¢;};úóE¡ª~­ÆЊè꘴N óüøcPÔ“ŒùaUK}J]Å$'ÄůýëéØu*Úuz½PEÝZ¦ž$_­Ô•Uä—kv³žd{~·x”@Ìƽ\^tæ8¿/Ó¸Ï+ƒcN4¾±ßd“MêÖ3!Ìdv~ÞE73ñF…wˆ¶ˆíX‡z—äãùA âÓ€¢žÁª=Ôoûì³OMÃ+\ƒ-6Þxcï–{ŠÃñÇïëºx¦f8—%*˜ñ¬®»î:Ÿ¿P†xlé¼à&‹ ÖСq‹ˆ/AA<Êž¸ÈÇ:›zœ}iâÙ–!mXÀ„É„ßÿþ÷ÞŠcñůáÉ=00ÃLSÊ¡Šwu7–¼C(¯¯° ϳByVã wCLCû" " " ý@@‚y?”‚òÐoŽ=öX?1&?1˜ßLðàEß)˜ÔL_‹þ¾Šú˜ôè§Ð?BT}‰x‹%ãAô;˜ B}ÒÛN8¡¦ÆµWã>ðÄØnÿ‡±>úEô¹‹ c=ð[†¼•í×’N™q½mE@’¤s„qêH„RêŽÐ~aÌÔ§Xc0ǸQTÙ2ˆµÁ‹êãP¾eêVÎm·žäúíÔ•eòî™m·êI¼­ ˆãz½#~ß…}ÊŠ±\Æòx7"óÇgô”zç8Uðéäø-ùÃ;i~œ:°h´ÅHŒ%@ƒe|ßìõ^çºh\UŽûæó0HŸ'"³\AúŠ€‰)î /tÖ±h*_öRt&˜¹UVY¥&¾‰^ά1Ý5×\ãÌ »3ÛYEâÌzÜ™Pí¬cã?[¥çL”qfQê&›l2g/[gxgî‚Uþ<qœ¹vÖYpæ²ØÙ,Wg/g•š³—¬3ËDg(g¾[j©¥œÍòù±ÙPÎÖÒ¨{?&9«èýy+¬°‚3Þ™K˜ºñ­òt+¯¼²3‹s×nžj@途$`"©³{Î,Ìýï¤drMŸ~ã7úúÂfÍ5}Nˆh“bœY;iÍÒsfîë›­çç!^£-¯QꋹrO>ù¤£Þ¡N0ÞÿÙÌUg®ëœ5Ò °d’³µtœyÒp&ÞfŽ‡ÔoÖ0t6hà¨mÖ½3ïáëÌ–¸6ÃÐYc'sܬœYS;›aéóJ~mrŽ³‰9þ¾Éõ§MPrÔ/q°õœ|™RÏê9›¼äÌ’Úç<ÖËiÀz×<„8›AÉĽšd)Êd›m¶ññM”öqë½lg"_‡ÃÇ:¾n®IØ6õ-õ½ Òø²*óŽà=a“œÜ[o½å˼èšÜ7ï›4álRCEvD@D@D@ú„m;ÚÕô›óíÂ>É¢²!]'`„cFE}—” ÚÎ<™…CéÖ&Y;Ò ²à‚ ¦ÇÃ}#ú1üî† \gÎ9çt69Z¶Oš&d;f•éój"¾{æ™g}LúŒŸm´ÑFÎ Dœ‰Þmõè»ÛÒˆ¾ïk–òñeÓ}@|ßÉÄ°ôXØ)Ó¯% øj -ÐÔVÚ'ð÷¿ÿÝ×w&L;3þj?¡g^qžN2Ksg†ΖSôc’¶–´3Ëq?ϸq?Q}ýË8?ãfŒc1ß(´[·R×ì½÷ÞmÕ“ä§Ýº²ÝüÆ ºUOòN4O¼uÇÑâ<µº¦cËjN+˧Óã·O?ý´3dì–1Nô)óÔéÌàÇÕ{g†›d¬ùŒ3Îpfl¥Û¡ÞëŒg3–_å¸/ãƒ$˜jÉ ó|#¢ð¢k%˜Ÿ?ŠÎ!-sÁâl p_ÓG47k@g³•ü)1=ôe8f./|§€—*JÕ¬½ÐÂÀâ‚9çá qJ-A<‹í›kdÝfâ#qíæ©èú:&eôJ0§áÀË¿@㘠0ü!hÒi7P'ØÚ1¾!CÝ@Áï4üV©SŠõ’­iTôUzŒú…A J\£Q ‘DG è(0q‡|òG#˜úû&~¨ëòç11Èffæg>3°Êä€~æËÜâr-â¨ãàG£‘ õ6“¨ïy‡ ˆêÿ2ïòÇ$‰f¬yG„ÐL]O\½1mE@D@D@:M@‚y§ +ýA$ðꫯÖàßcMùñ ¾7«/÷üóÏ;óÐU8…>}½fCèæã·Û'ͧC_ ±œ~m˜üËär³ôóýÜvû?䯙~ “˜Ä^Úí×’V™q½¢¼è˜ŒTý ˜3ÈD&óvéëVÆŒ¨K9Ζº‚1{„FŒ%¨Ÿ—c,¨Õ±¿VëVêšvëIž©²ue«ùŸãnՓ;Wã¼5»Ï˜#ã‰õB»|:9~‹áÑOúS/z£W1iŒ±j&±òG;‚gQ;|f<ƒ¨k¯½Ö?3L9묳 o»Ñ{½㾌j`>¨%§|‹€ˆ@Ÿè•`Þg”X̶è”qè ~ÌvÉ1„a’MQ@,'^0–(Š£c"Ðk9¿J@IDAT4a‘ý»ßýÎeÚR“ÎÖfÏ<×<ËÄã™gŸ? 8ÿï¹çgËy:[~ÀÝvÛm½¾¿¾ó/BÝ€ˆ€ô æýQÊ…ˆ€ˆ€ˆ€ˆ€´K@‚y»ätžˆ€ˆ€Œ ý ˜ Һˑ@`̘1ÎÖ¼÷žÖ[o=‡`Žuy³ï•xeaéÞ³Ï>»ÙÓ¯ æuÀè°ˆ€ˆ@k$˜·ÆK±E@D@D@D@D ßH0ï·Q~D@D@D ¿H0ï¯òPn›À²Ë.ëÆŽëob³Í6s^xaÓ7„¥ù‘Gé>ø`ïÎ}»í¶kú\E,& Á¼˜‹ŽŠ€ˆ€´H@‚y‹À]D@D@D@D@úŒ€ó>+eGD@D@úŒ€ó>+eg` °ùôÓOï>øà³Î:«;þøãÂy½¥ÂÍ>ûì³îW¿ú•;ÿüóÝüóÏï.¸à‚†k·‡ó´mL@‚yc>úVD@D IÌ›¥h" " " " "Ч$˜÷iÁ([" " "Ð'$˜÷IA(O ñQ£F¹ûï¿ßß "9â7VçË-·œ[pÁÝ´ÓNëhŸ¿óÎ;~Íò—_~ÙÝu×]îá‡vãÇw³Ï>»·._j©¥žG?Ü€ó~(åAD@† æàu " " " " #š€ó]üºy’€ó!)‚4MàÜsÏu»í¶›ÃÃI´Çg™e/–æ3ŸqO<±ûÏþãÿÞÿ}÷ꫯúýÑ£G»í·ßÞ ìŸúÔ§ÂéÚ– Á¼<*" "ð$˜ÿ 퉀ˆ€ˆ€ˆ€ˆÀ `>ˆ¥¦<‹€ˆ€ˆ@÷H0ïk]iøxûí·Ýµ×^ëÝ«³–ùÇÜð¦g˜a·Új«¹¯ýënùå—wóÌ3ÏîÛ&¨/3$˜gp胈€ˆ@»$˜·KN牀ˆ€ˆ€ˆ€ˆ@`Þå \ˆ€ˆ€ˆ@¿`Þ¯%£| *ýë_î‘GqO<ñ„ûë_ÿê^zé%÷Æo8Äô馛Î[›Ï6ÛlŽ¿EYÄÍ9çœþo²É&Ô[îÛ|K0ïÛ¢QÆD@D`°H0¬òRnE@D@D@D@D O@‚yžˆ>‹€ˆ€ˆ€Ä$˜Ç4´/ÕÀí:îÖq»þá‡z·ë¸dŸ|òÉýßSLᦙfY”W‡¼&% æ5Ht@D@D ÌÛ¡¦sD@D@D@D@D H0PND@D@D  H0ïÇRQžD@ª Á¼ ŠJCD@DÀI0×C " " " " ƒM@‚ù`—Ÿr/" " & Á¼Ó„•¾ˆ@¯H0ïy]WD@† æì@u;" " " " #Ž€óWäºah‰€ó–p)²ˆÀ`>@…¥¬Š€ˆ@?`ÞÏ¥£¼‰€ˆ€ˆ€ˆ€ˆÀÐ$˜ÍH1D@D@D`$`>’K_÷.Û@Ë‚ùI'ä^|ñÅáMEw'" "Ð2n¸Á½õÖ[nÍ5×tÓL3MËçëÞ¸ôÒKÝÿþ÷?·É&›¸‰&š¨·™ÑÕE@D@D@úŽÀ?ÿùOwã7ºé¦›Î­¾úê}—?eHD`døüç?ïvß}÷R7ß²`¾êª«ºx ÔEu²ˆ€ˆÀð#ðñÇ»$IÜ$“L¢ÁµáW¼º#@à£>òw9餓Ž€»Õ-Š€ˆ€ˆ€´J€±?Æ™XÇ ‚ˆ€ôÅ_ÜÝ|óÍ¥²Ò²`¾ÄK¸qãÆ•º¨N2Юï½÷Þ2I8 æ¥ðéd^è‰`~þùç»×^{­÷«kŠ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€'0óÌ3»Ñ£G—¢Ñ²…ù{ï½çר(uU," " " " " " " " " " " " " " %L2É$nÊ)§,‘‚kÝ%{©«édè-[˜÷I¾• (E@‚y)|:YD@D@D@D@D@D@D@D@D@D@D@D@D@D`P H0Ô’S¾E@D@D@D@D@D@D@D@D@D@D@D@D@D@J`^ ŸNT̵ä”oR$˜—§“E@D@D@D@D@D@D@D@D@D@D@D@D@D@•€óA-9å[D@D@D@D@D@D@D@D@D@D@D@D@D@D  æ¥ðédA% Á|PKNù(E@‚y)|:YD@D@D@D@D@D@D@D@D@D@D@D@D@D`P H0Ô’S¾E@D@D@D@D@D@D@D@D@D@D@D@D@D@J`^ ŸNöß÷ì³ÏºcŽ9ÆÍ>ûìá°¶" " " " " B`›m¶q}ô‘;÷ÜsÝDM4 ¹V6E@D@D@ºEà™gžqp€›o¾ùÜ¡‡Ú­Ëê:" "ÐqÌ;ŽX‘A`饗v÷ß¿ûûßÿî^xá‘qÓºKF¦žzj÷ïÿÛ}ðÁnâ‰'Fw¦[¨‚À¸qãܲË.ë–Zj)wÇwT‘¤Ò¾ Á¼/ŠA™Á'ð•¯|ÅÝwß}îÁt‹,²Èàßî@D@D@D@D@FÏ~ö³^0ÿøã%˜°²×튀ˆ€ˆ@30”5j”Ãpfìر͜¢8" "0$˜D1)“" "Ðÿ$˜÷)‡" " " " "Ј€óFtôˆ€ˆ€ˆ€s=" Õ€óáZ²º/è2 æ]®Ë‰€ˆ€ˆ€ˆ€ˆ@Å$˜W Tɉ€ˆ€ˆÀ0# Á|˜¨nGD % Áû¬ûÃþà¾ÿýï·å6÷ª«®r=ô›cŽ9Ü–[nYY¾ú5¡W_}Õýå/ñëìM3Í4îàƒî׬ö}¾Î;ï<7×\s¹VX¡§yíV}”¿É×^{ÍÝ}÷ÝÞåÓO?íà¡PKà…^p§œrŠ{å•Wür=ßùÎwÜL3ÍT±GzyíÜNW“”`ÞUܺ˜ˆ€ˆ€  æÕÙÿþ÷?÷ÜsϹ'žxÂ=þøã~d†fpsÏ=·ûêW¿êh›Uè?Þ=òÈ#îå—_v|~ã7ÜÑGí¾øÅ/V}¹JÒ{ï½÷\’$m§7%B90ÆB<öØcî£>òe0Ï<ó¸ùæ›ÏM5ÕTE§ yìõ×_wO>ù¤OΟúԧܬ³Îê—5ø¾0äùŠÐ]Ì»Ë[WaK W‚ùÙgŸíößGæհð »n¸¡ÕÓ_F4}÷Ý×7®# Ž8⿉#Fxà¹NHôôÓO÷Ãn\q±ª@'ñ÷¿ÿ½ûõ¯íîî¸ã‡ÜJxðÁÝèÑ£Ý?þñ7óÌ3»û•Ó".ï…ûï¿ß1 sÏ=÷øN/¬·÷Ç?þq î£ß2Éó·Ê*«8,6ÝtS·ûî»;zºUq¯üFøÝ°eÀƒÁ~L¸y÷Ýw{qû}ÍÝvÛÍ]pÁŽ‰ úí¹çžnï½÷îJ¾{yí®Ü`/"Á¼ƒp•´ˆ€ˆ€ Ì«+ÄÛo¿Ýzê©îÅ_to½õ–ÿÃ@öíœsÎé¶Új+·ñÆ—¾è‡~èn¹åwÍ5׸‡~ؽùæ›îŸÿü§ûÏþãæŸ~Ǹ.ý«Ùf›­ôµªN€~üÖ[o]J0Ç›òù£wüñÇ»gžy&-Æ(ƒ©§žÚ}îsŸsÛm·[ýõ]³ÆpebõùçŸï9Óg¤ïÈù“O>¹ŸHÌtú-è ýA@‚y”ƒr!" O W‚9³0D¼þÝï~ç÷Á\n¹åü?âÕŒ3ÎØsë¸Fy‰ß]~ùå~†ë{ìᦘbŠ‘ˆ ïïùÜsÏuwÝu—û¢v•áŠ+®pl°O’ý6Ú¨ÊäkÒ¢£Ï ân\‡:²Š@'ëØcu_|±{ÿý÷Ý‘Gé6Ûl3÷éOºéä9ïÛßþ¶ï(#~Ò|ûí·›>P"¾óÎ;n½õÖsXš"l"z†°Új«µí$¤1R·<3W_}µŸ¬Æ ˺ë®ë-x§v;t«>ºòÊ+Ýa‡æ'˜`yÁo(³:í¥"\kжóÎ;¯Ã?„e—]ÖÝyçácG·½¼vGo¬ ‰K0ïd]BD@D@˜€óò…‡G=úõ—\r‰·ôfü¶ÛnëhÃ2ÁûÞ{ïu×^{­ˆ³·ß~{/¬N:é¤m]üæ›ov§všÊ…WX|ñÅÝZk­å'“ãun–Yfñbyðú×Ö…:t“ vÞyçR©3‰~Ô¨Q™4(Æ’1¦`l™IEaâ‰'v .¸ [sÍ5}¿p(kóçŸÞrÈ!î¶Ûnóý!¬ÔwØao½ÏÄk®‰÷;&ãE1ŸòPè= æ½/å@D@†^ æÀcð±‡ÆÏ׿þu?;²*ƒù ò/´ÐB~– npú‡Ó-¶Ø ÌzíW7PýC¬79á·Æ$îº.½ôÒLFèÀÑñc&t>ð[EXÂÚ·Ț¦¬C§„Îâ&›lâOÃ* èu×Xc GGWêüÑ‘ÃKnÉãÀ l:Bt~IùýË7Ä¢)ón\‡É:e"Ö™—]v™¯ÃN:é$·êª«úÙÉ­¤ÈN‡,p®‚93º¯»î:_§œp Þ:8p’`H´·…íرc½V×LLøå/é;üí¥ØÞYݪ˜œÇýr½sÎ9ÇýùÏN3,Á7AছnÊŒ]2¦QÔ·7Oi‰-•ö=LlMÌ2¹‰+|…v-}43JÓ`¼†ñ³2o:^G´ÉÊIhŸÒ÷Z~ùå“o|ãɆnØð/'úÞ÷¾Ws<Ça Ù\®'ûì³Oræ™g&¶ü]b"zbá‰Y’§ìBz6Á!1‹ýšôŸýìg‰ óéyf½îû’áû°5’Äm:抬nÇá§?ýiMl¨4x‡Ásež˜ûrz·®ç£Õ}[;+ùÑ~”ØlæÄf{NLfÞ†ðóŸÿÜ£cnÜÃášm+‚9'Ó9´ut}ÚˆçݺNMÆ[8À ç0+|›m¶iªƒœOžßêÌ\6wf ³¢Ãon$ææÆ>½_î{8 æÌŠŸ~úéýsž:ñ™Éûí·ŸçËsÅ—^„NÖGñý0É'üvز`Þíg%æØûâñI©H0ïǧSyþ! Á¼ý²7n\jUL_–"LMR¤¯µØb‹¥ýúóñ¸IQNÞ|óM/ÓO ý,¨o1osŒ Rx饗’™fš)ù¾`iŽ˜ÝL`Rw˜h`k³'ôã`îݽ—4Æ"ñÞW¯ àgBŒK¶æ:½e~|Š±®F¾sœ®-CX˜n£4ô]µ$˜WËS©‰€ˆÀˆ%0‚9b‘Bÿ ¡në û†fÜ@d_‚yÿ”S£œ >çË®ÁÜÖ@K¾óïdÜZvØa>m[ë©Q’|‡„üÔ³0 áòŒx¸3ëÖuµ[Ý2C9té¤1“º€…5"*B܇Í7ß|iÙI0o‡hžƒ‹ôP¶L éVÀº;LÂ`~#+‰Nå©“õQœg<5ÄõÞ  æ½zVb–ý´/ÿWÌÿ…öD@D@D@j H0¯eÒì‘Ÿüä'™¾C…099ôA^xa¿Ô]½óˆ¼êq"û©§žÚUoOõòÖêq–Yš|òÉýØM=Q»(ÍwÜ1åÌXS>zè¡þ{[<Á3U£€h¾÷Þ{§é¦ŒÕÄþh苇²jl!ŸqšŸ¥Îz¹Ôi|?#u_‚ùH-yÝ·ˆ€TL@‚y-Pf>âÞ³“k­uÔÎ5i|6²äm'Ízçp-,Ëç˜cŽ´aˆl‡jTÖK—†l+èzéÔ;ëfg´ÖK#'-òÛl lúm6pU”'žx¯;xŒ3Æ[O0WbB;‚ùÝw߬¾úê nººuF÷Ðè;:zaf4½vžïÇ<¡SÍo ^ŠŸ‚á ˜÷òY‰Yö˾xdKB‚y–‡>‰€ˆ€ˆ€d H0ÏòhåSpÆ¿š1ìÁMwˆÏvâ‰'®;AËê™gž9ûí·¯ë¼•¼÷".}¯ë¯¿¾%/{ï¿ÿ~Æ-úW\Q“u =ªŸ|òÉšïŠÜqǦ”†qÀž² eŲeÍŒ±®°Â é9œË˜BïLÄ¥­ D@D@D [;ÜÝwß}Îf¹EY¤TZeN^z饉`…IXCÔtÒI…ßUqÐ\9s§ãlNg:g‚¨3ÁÜ™E§3±Ê­¸âŠÎe…—zꩧœÍœ,üŽƒÖèrn¸¡3 Sg맺+¯¼ÒY'ÅýãÿðçÌ>ûìnþùçw&¨9sµT7ø Î%¿¶ÞÏïo¼áL v6{ÓYÃÑ—£¹¸w&¬Å§ù}îÉf¬Öoæ€ ~î˜cŽq§œrŠƒYQ0áÅ-ºè¢þ+› ël-^gkY×D…¯Y…9s¡äLXu¶–“Ï—¹kòù6ÁÈ-¹ä’5çÑü1¡´æx|€òZ`œ‰‹ž·uRœ¹âu&ù´­Óá¾ô¥/¹»îºË3ŒÏ÷m†¨Û|óÍÝDMäxàŸW˜Û:FL\ôejNÜ·¾õ-7Ï<óħº¿üå/>¾‰ÉÎÄ gëO¹¹æšËÙÚSî›ßü¦ƒM£ÀsøðÃû(Ë/¿|ÛeVïÖñyŠ¿ç'ßͳtöìømæÃË/¿ì^{í5ÿÛitŸG}´³Ô™ÓÍÂÜ3ÏŒ>X§Å™ˆì36£·+×áwÕj ì¬óäŸÎ5×ìnã7n)žß­·ÞÚ™ûy·Î:ë8s9ì¬íïÝ:‡>-̪<ã<òˆ£n¡ yvùã9¶Iþ·×#ï¾û®3áµ&ÔœuÏ^Q0k_gbOÍW—_~¹ÿÍ„/Ì%»3×jþ#õ¿M³’v¶f™ÿÚ:fÎÖ чܶz¯¤n¦>£®‡uð¼óÎ[x_!›Ýî~ðƒ¸«¯¾ÚÁ‡@Ýî‘϶†›¯ßÙCUy;v¬£Î%Ì0à þÖÍö@'룘õRüžå™£Ni6´S¾õÒ¦¬){Ú¤kK78³ô÷Ï ù* ežžK›päßW¼ y‡ÑæâY¥Ìm¹‡ÂgŒß5¿1Þù¶fcQ¶ µsù„†ºv+<¨h'5 Ô?yö¼¿©gâ@›€º·ùçÝê_ˆ ˜PèF壠Ð<úGŒ…pÐA9óz>néS3öƹïŽù>²ø1ªðãh”c[#%Ð^k­µüØý#Æ~ÃŒƒY˜û1F³0÷ãñwEûŒ—F,¥Ò˜sÎ9ÓèGq„£¹ôs»÷š&íPO˜«<ÇÞÔip£¾áB½¾ë®»ÖL²™ì~…‰*LDó複@ýÁ¤‹0y£Ê¼s Ê™²åÝDØa‡2åævð_·ê£vóvË·Ï*ïÞ§¼Ox^({„NÅho˜õŠŸ`OühçYá9äÙbÒõ¸Þ/ðf é¯ý«V¹6;x/†I+<Ë·Ýv›ÿcŸç˜¶ÇP¡Ýû‹ÓmæÚ­òà½lk?Æ—©Ù§Çï4æ)ÄO‚‰±¿ï¾ûúwyþx¯?K0ïu èú" " "Ðß$˜·_>´‡ßzë­4ÝwßÝÑÆlè_åÇ~õ«_¹wÞ9s†$m´‘ïÓ†/ŽO£_ÉDRúá´õúuâfÈw™íN;íä~ýë_û$6ÝtSgËÓÕ$ÇD^ÆâÔ› ô}èWÁ†ŒÓ‘Fk®¹fFèf¼ƒ¾ÑPáç?ÿ¹‹Ç7Ó0XC¦ï;EÀ YAD@D@J©.Ùqd±Œ»k0ùµ¹q…tÁ$f5œº×1¡3±[ëž^x!1Ñ=16kïþÌþ˜ØlÔÄäÌñ8ž‰³ ®…L´/,S܉rÈ!>¿q:”ŸY&&& {WºqšEûfåZ˜~3YKÙÕ3Ìò×0‹y‡x .¸`bÖs™¤q¥Í}Z#5eAžpÕd‚Pb–•éñ¹çžÛ» æÞC°Ž‚_çz‹-¶HãåóÀºOÛm·]b¢SaX[#<1$±n]÷ò¤{ÜqÇ%ä#ø3魺ꪉ‰É>ûì“®lj÷­ƒ“°þU½`¯Ì³Â}˜5|½èm7Q£æž(—f‚u.uët4½nœv\²×M¬ÁݺNÈ‚uŠ3Ïnºxn[ 6Û?±ÏÞ-Ø駟žqçÞ)—ì,5p°­ÏoØD³Ä&«$çwžÿ½Y'0á¹5Aϯ£vä‘GfnÇ:øþ\ë´fž+®3ñ^|ñÅäøãOxÆ©Sãß… $d↗]vY&žM8Il`Â×¹ÔÙqaß3¿C2™m™{²Îwb¡\¨Û„˜Ä¬Ûël'”9¿òC}Íá6Ù¨ÆmœyìH`â†ü³þ™MÄIÿx˜°ê/]UÞãû`ß¼¤,m"Pb~òQ:ö¹[õïýÀ˜-ï¡F¡lùæÓ6ωM4ñ¿m®ýµ¯}-±Á²wŽ¡-fÞü;”w˜yH“håY ¿GÊ”çË&å¥÷mÞ›àRó~亸<´¡Ä&L$æÙ$± /¾.€Õ¿øÅ4/õvÊÜmŸV®Ý ~;&þ',“a“ORáYXyå•ýÚEKʘW ÄÄñô~ϸÆ4Q¿†ž§îæ¾lRMOó¡‹‹€ˆ€ˆ€ô'¹do¿\ íG¶æMqÈÄè»1^Ÿ·çž{Öœ÷ío;‡ø'œpBrá…&ßÿþ÷}ß–¾ƒY¦û¶¥ð³MàϤÍøËè)ô†³"D@D@D 40Hk.ÙK§U&s!žihÄ J“« 4Zƒò"ƒÄ6cÔ_ŠFŽ¹@Η Dš»ï„ç80{öÙg×Í?÷ƒ¨‚HOC7¾¿°Ï@.mQ8ꨣj&ÎCL2«k ‡Y_¦MÚ¿FBmÑuãcæj;¹ýöÛ³Ì.¼ù¡ÁHþX+È,Ó$ÌMµËm†lz>ÂŒYšû8ã ØÇèϯ[DÙ°¶sàø…-òe¾ [¼é\˜…_b–vi~Â÷aËZíä×f÷zñQ9|o);Ê•ûAarÏ-‚C/ì›åkBý(PN!^ØVÕY×kW ‚×à;}0.º%dwë:bUü Ó™m% ’щ£ìYû<ÔI!N æˆUˆÖ\—zʼXøο7„n³ŠM‚@mÞBvü–ß.b¤y¯È<»yÁ‡ûcÝá|¹ð[/ yÁœÎ,¿KòÉ9üæŠ~ïä•ßk‘ð[æ^C¹ó ’|þóŸOÌòÛO0k^/Ò3ÅoÖ¼¤<ˆ³Ád:Ð=öXbV¾‰yAHãq_¬[Ïñø/Lª"ïáâm¾<Î9çœøëŽîw«>jE0¯¢|ch<´·x.yfùË_&¶NbÞ'ü3Ê;“‰”?LÀ0i­<+æIÆOX‹ë¡.ëÕ3ñ%ÑÃwæ-'1Ï…ïÖ¡ó²÷ÇÄ¿V®Ý ~;Ôc&Lðm¿p¿a˳Æ/™ÍúßOt B;u3ucø=¦Ô';Ìû¤ ” èSÌÛ/ÆCû‘-“š›¬ã6>çÙ}™L0ÎÆšÜqÚì3#úñãMôÛ™`Á}œáÌ{zŸôU0D¨"˜WÉ [Æ5âÀ˜eÌöÖ4.¹ä’LÚœ[4þÐLZŠSž€óò •‚ˆ€ˆ€‰‚¹¹öÖ’qƒ”e¯ã€P…e`Ù¡XåÖFq¼xŸVf‘b]Íà8×að9Žö‹f;"çóA|DW„†8 t…´Â–ÆŸ¹…÷BÆeƒ¹ñª¹F¸V‘…V¸3có Q,àâN÷Ã}…ôØ"z1Û4è@Äñâ},4™j®m ãÄ‚Ÿ¹«-ŒCztN°ˆÅ‘ÏÜÉ{,¾V¼U0“'Ãi(_zé¥ñ4Ž[ObrDq£ê -Eâ>ÂAÑŸ­é” ¦À3ˆªÌóOä'Ÿó¢1¨V",¢uDѤŠN æxzÏÝ­·ÞZ“ež,S‰ƒÅyQ°%*Ò4ˆ—ÌãsòõH³‚9éò›0·÷ Þ@èXã¡Â–EÈŽÄ£^/Êk÷ÊïÜ– ð÷Ëä˜ü@B[~rƒÞù¯ƒ˜\U/T‘÷¢´±À…Yøc²F·B·ê£Vó*ËëéUVYųEÐÄR$?†‰oqÙRLƈ'QÍ<+”%¿‹]vÙ%-ÏP® ÆaÁ‚W¬´Ãû–k™›sœßUþÝÙH0¯âþl锶®Ý ø9fâÞ2¶Ô%×m&Dõs`ÞÏ¥£¼‰€ˆ€ˆ@ï H0o¿ 0ºˆÛŒ9ѧ*ä-Ó7Ûl³Ì)¶Y&Ýp Æ[/ÃKR0¼É ë|¦Ýžï‹f.ðÿ?`èC{ß–Lócš¶L`2f̘ÄÖY/ŠÞò±ÓN;-¹ûî»[>/œen¸á†™q§íÚk¯òÅf^ˆÇkh`¶¶ÜZS—¢OÎ [ ‡zC@‚yo¸ëª" "0ìŒ4ÁœÆQ‘Õ/ƒÆX åC‘µ/‚áwÞ™‰Ê`oh å·4pù>Xyåãñ™´c™s°D+ŠûÕ¯~5NÒïÛzH5qp _UÈ ]qÞê æ¶æ²·ª‹ã²Øa‡Õd ±(Ž‡xˆðœEeÎÃ-; _„f\$‡ãl±PË˾øûxëóØ-.yÀ¥n'ì‡|Æâ>b"zˆo™ \xV°â¦|m+/º!¾UŠ*òånÑ¿Í`eÇ}H0/.‘Q£FeÊñªÙ€C€°Êùº€t:!˜S÷…‰”-ö¢À¤„#ꯢ@<~Æ æLÞ‰ã¶"˜3ã›ßIàÃѯ ùA\¿/乊{eY‚Å[ÌçŸ|cqZ¨;òz»YѯŠ¼å“cLæŠËÝrëÜ­ú¨YÁ¼ÊòåÙdÒõ+|yäEðP&¼çâ2 È ëÍ>+¤Éû/N}ž?¬³ üfnºé&?PÆ6´È3ºâsë æUß_+×æZáA|žéï~÷»™{ãmkBòuaØvÛm}|ð¬ös`ÞÏ¥£¼‰€ˆ€ˆ@ï H0o¿ òî·i+¹W¯@Û6¿T †qÈ{ú"]–|dâ=†¬ß opÃŽe{ÜNgŒæ`[Z­Q Üé‡,±Ä¾JŸ™~22*ŒMqvýú½íz´Ì»cgòrÉÁãŒä˸Å<Ù/Š—?ÏLÈŸËòž ½! Á¼7ÜuUvFš`ŽÅ_‘›Òz}X)ç@|Î[ßÍJ çY˜²îyø>ÞbÁ­ÃÖŸÉ⯷Þz!JºÅ’<|o±Æ®*´#˜Ó€óöóîÈ#÷¾[äC^q°â Xôãñ™rƒQ,j34œ›ßbQžXçãñ7»EBH~@8wË-·Ì'í?Ó©Â-×ÆW±U‡"ŠŽÜꫯ^ó‡×ž:m8!ÿÌkK…²Ã+A`ĶYïx0 Ë9X<²~rQè„`ε‚%×_uÕU ;ÌÔM<»îºkQÖü2 ñ½7ÌñÀÇmV0gBG=q‹ßJÑï3ž˜SÅ½Ò “G–\rIŸÄÇ¢¿xF;÷‹ …‹û84+úU‘÷øºñ>"q\¼‹êqŽÏ«b¿[õQ³‚y•åË„™à‰€ßXd‡üD²z‚yÕ÷Gš½6q[áA|†AX† mBÚdE Á ¿ÝÀ¢t;u,ÜW·&»tê>”®ˆ€ˆ€ˆ@gH0oŸ+c4 -´P¦}M;±Þds–ð9ýôÓkÖ0Ï/øóÎ;gÒœtÒIýúäù~9ç“ÔqÇ·óñHOïïQË,³L:7>/ì# 3îsÍ5×ħ6½Dg&š¶bwìŒ3å—Ál'Mú7ñX*Þ¼ò“‘I·Hô>÷Üs›º$‚|`¶1)ô†€óÞp×UE@D`Øi‚y½õÃS‹ÂI'TÓ¢!„[¥x€¹‘`~Ýu×Õ$ÍŒÉРÊoó¢kpƒœGƒ/Xï;ÏÌ‚U3¸nŠC;‚ù +¬P˜¯"÷¦[l±EM\žÓ|¨'˜/µÔR™²¡œ^zé%/>ã:?Ï·‘`^äñ­Æ!¿õž¹¼+®¿Û" !”ÉEt¬ïºë.oé&H0¯-)Ûü„œ¼8Z{Vâ×ÃÅê‘ PÄóz¡‚9âJl™è²îºëz1*®çÈÓµ×^[WôËÿ–:!˜5ù穧žª™´À½„PŽŽ=:­˜(ÃàB½¿ ¶ÅuqhVô«"ïñuã}Òfp&ÎgQýŸSÕ~·ê£fó*Ë7ö&Ã@V~B\ž!“¤.ºè"?HƳœÍ>+œÇ€Z\žì7㮑s©ïãsë æUß_+×&n+<ˆO  hóÅ÷G]O¤û$f’.«‚‡€nýµÛÙJ0o‡šÎ‘C@‚y¹²f=ì|ñüŽÑwfÒ1“J·Ûn»džyæÉ´9iæ jò#sÏ=wa»4䜥œŠÆ)‹¬Ì‹Xzé¥Ó<0‘wóÍ7÷ËâuÙƒ _LîÅz—íù1€píz[ܱ“ÆPKÕ;?ž4_¶±Þ9C§ÏÆ8^xa¿DeÑ9E¢w‘aOѹôÝâ>û¸¹Wè  æ½á®«Š€ˆÀ°#0’s}ÓM7]Mƒ†F bUQ`fa¾Äg,ÀâY­ æõÒ%í¼ {È!‡æ†d>œwÞy…qiøÆÑk¥•Vjê/ï½ÁÁ¾ˆ#w,êâ?\çã²æh¾Ñ^O0ß`ƒ â[r?/òÅ×. g=ï8NØÏOJÆj;ĉ·ý&˜ãŠk¨À,if(óüK0¯¥•wkMy‰0ù3é`óŒcekäF¡‚9× n‡Ã3ŠxŠÛq\Æ=þøãi–X h¶;ò¿¥NæÓÂ/kž…û`Ë@EÊÞ+ë=‡ô™<§VþòV­ˆ~eósÈpo”g7B‘`Þ‰ú¨YÁ¼Êò]`Òge¨É5¿/žã¢ÐʳR$˜çÛE×àX³‚yÕ÷×ʵ‰Û â‡pË-·¤ƒƒ<ï¼Óòƒ—ÄÝd“M|ùQïðþë÷ Á¼ßKHùÞ`^Ž?¡XniòÉ'OÛø¡¿‰øŒøM»ñ+_ùŠŸÄM3ô­B›#Ž8ƒ„qº¡ýšüÚèk­µVÍiôåƒ ŽPÎ8 Ë31~ÉØÏ“bQ×êGyä}ÃÅè·pmòßj ‚¹pÿXå— X’Ñ4áDŸ‰E!ßGä&406 ù[Œ˜zC@‚yo¸ëª" "0ìŒ$Áœ™ž±ÛáРa»Ë.»–m~MÑø\Cè¤`Ž€–ŸÅJ>Š¬®=öØšqó.Í™õßK£ý“O>9ܦ߶*˜c¡žï(Ä×£ÿÅß…ýÉ&›¬Fx¬'˜³6S+!/ò…k²•`^KÁkC æµlÆ—ù]a•˜Ÿè‘?‹uÉ‚ÎúeCY †¸<ŸˆìU\Çç×Cãˆøxˆ8ñÄ ]˜Å×Ïÿ–z!˜“ŸcŽ9¦¦eC(s¯xƒðaÝ:Ül·òO¶"O­ˆ~eòî¿Þ6oÁyÝí æä­•ú(?‚Ûó|¨²|™,[í31¬lhåYé´`Þ‰ûƒO³b=q[áAüÈ{Þû ƒjñD~§a’å™ë†´úi+Á¼ŸJCyþ# Á¼|™`µ2úâ~!}CÆíøc¼×ëa¼•ïøÃ5z¾¿„Ý'öŽÖ(·yÏŒX¦Çáµ×^Kfžyf]ÒD(Ûº!.íâ¿ýío VÞaÜ/i»ï¾{òæ›o†hu·,yÈØ,Ûh50ÞÆi÷clµL`’+}tÆb/9ÿüóëNøç:”G¾O8ᄦ²ð—¿ü%3î@vkÒySa‘$˜°×튀ˆ@§„\³ëìv*¸Ñ Äüv·Ývk벸A:þøã“'Ÿ|ÒŸø™O;|¦AU®ºêªºçÄ3;)˜#8‰Ã¬•L#8y7£áþ.¼ðÂ8šw¾j[V0Ç:µÞ5h¸ãž~¨?,¿òÖ]EL¸ŽóLQ~(#P‘à~ûí—”µGÎ?tfªݺù?~|æžèøuJã{¤c&Äà ÇþXk>p£CÇÅË,´È'UDî~¼eÖ7Ë@°ÆW½Ð/‚9ö8ïìÇë••¹× &dÒ>ðÀëáhúx+¢_™¼•¡yç7soƒ ˜sOÍÖGÍæU–/K+ÄÏ!mÙÐʳÒiÁ¼÷Ÿnæ\ç²Ë.Ë”(bXÛP~¸®Ì·µ8¿ƒó~,åID@D@ú‡€óÿÇÞ™@KRTy?æsâ(›¨ˆƒ ÒˆÊ"(K‚ K (›ìÐÐ 04ûŽLƒ,²c7KB+;¨¬‚쨨€ ˆŒ,€¸Ìu<ž™üî/†›™•U•U¯ªÞ½ç¼—Y™‘‘7–Œ¸ÿ»4ÓúÓŸüškbdŽÈ,‘)ž~úé>¤@*îº]tÑÂz—˜ðîPV¯CX‡Ï‡Jâ—^z©—3,¹ä’F/í‹sd' ,°€ÏÅyöÿ÷Ýw_é£X¬«üKùX ôÁàÆKZ¬óË,ÁƒG*Oi<§Q³Ï>»À“²cÅñÃ?¼,iáz*$&|4š`>1|··ŒƱãÀ¸怫,¶pïͦBà©À”.Èô蔢*ÀaªR?sÞƒ”…œ.(±x]ê’¾¯¾úªÕiaþüóÏç `å·‰›„ ¦vþc2À<æHýß½ælˆõÔ ÈÔ{àÅo~ó›–¾µ)~….ûÃÛý©öµŽ¡0=›Ú»ï¾;õšZט7ÙÜOŸ>=SàEßÑM8ÊMóçÏOæ7,€y\6˱ÂM·ucœ!Dè•:AyW·eoWN€Á°½Q: j>ª˜7Ù¾q^ï{ßûzfg'}¥ß€y?ꃘ£Œ¸ÒJ+ú|è@ׄìiç)¤ç†m(·Û)j5ô:ËÆ8`0ŒÆã€æÍ6²8Ü´£´ŽÜ‹s]‡sÎ9…u&ÖÓ(çÆ4cÆŒB:<ÊÕ!¬Üýç¡ìAã‚ï±Ç¹Ì°]¾xå¼ð ½Â¨îÿY/Ïœ9ÓË +¾öÚkþÀ°ùŠü(­wJÈôµ±±N§ù!§@ÑEX¬ÄC~Tå¥a˜´ÈPëPÜÆï~÷»»R¨ó.KÓž˜·ç‘¥0ŒÆWÀ¡2‹$o 2àZHAá‘EdŠª\²‡–HýÌÑÔ$vôÔ©S å§>Xú"ÐÕ¶ÔzQwêõÌ3Ï´Tm€9eW-U-›§M›ÖR¶ºT˜­yéÑ,ÌÛs°W€*~c‹MbJ±!N«¿dê=Ô ÷Ð1 ÝNÃ8̵÷rdžè…†~õ«_y/a,³°Lþð‡³Gy¤å51P=Q.Ùq–÷CúPKY¹ÐM]„ŠWÌÁ¸ñî…:Aõ=Ý”]ŸMö„îÃáßã?žJÚøµAÍGuó&Û7Î …ÊÐ uÒWú ˜÷£~ðfP€9ïB θm$´ÂL\K2Öïºë.’Ž`>Íd…4ŒÆãÀ„qÀóÁ°Wæ+®¸ba €­`zX ¬ ÃõhÝÐwXw‡ÏṌ’Æ¿âŠ+ôR­#{[<<~àÈó_d‘E¼¢)FIü¢‡²UîÿøÇ?ÖÊ?L„LUÝ¡³Žm'; ŸÏ¿ûÝïzWøì¹N>ùäZîä5Y³fåu…§k¯½¶Þª<tÐA…çð`4q0À|âxoo6ŒcÅYÇÉ%;-‹8:h+ª6 ÇÂ'\Tê9ñR„«pM•”ú ˜ó¿¸RÚqÇ ezË[Þ’±€EAàï|§_$£q–QËÊ‘ØBÄù­óG¬£:aγS¦L)”Yyùž÷¼Ç[—‡ù×=7À¼.§ZÓ5 PÍ›7/#öV'ZŃ²õ¸ ˆ{yxôÑG[ ¸Â7duÿtìpd3?‡Õg§ÄÆ÷Ä¡6næˆev 'xOá{9Çý{LØǮѶÚj«¼¨½Ö•ç™o•j7ÜpCž»æO¾7X (ÕA{-»¾/uDÀ¡uÒ£*›¥Ò7ymPóQÀ¼Éöeí•ò“#ßܺ„éž{î)$¯ÛWx¨ß€y?êG¹ ˜cE i#<ßÌž=Û·ÛòË/Ÿ1Ž `>*-eå4ŒÆãÀÄpÀóþó5òà÷êº ¦yÊ…Ò ¬©é8¢€çºv‡â!­¼òÊ^ù³C”F±¼Ž ²bY¾Ûn»åa0Ã÷×9ݱ¯¹æšI…‚:ùà˜ò”ç¸ãŽË¦ªž åÄÈ=B¥x<¯…÷ËòÙpà mGÜz£‰ã€æÇ{{³qÀ8`+Œ#`~ÖYgyð˜…1²C"¶P¸ÀÓóÍ6Û,L–ŸŸyæ™Éô,FYD* 0'>2®ã±–¤ÜXfá6mJþî¸ãï Ð ÷FeDÙ±«ó€R7€yYlu´IÑŒ­"ʘŠËl€yתï5 P8¬°Â ¾O²i«Kƒ²õ­7qŠu^áx§„J¨"€JúwÝ¿¥—^:Ï-òø¹ªq_VžÁj<5M¹kÈ$Åæ©4úÌÓO?×>áN>E± e¨v„ûµ° ð¢ÔD]>„ùS¦:|ÇEóÖûÄ5w¨œƒ Ìí)j¢ì©|¹†EmX'”ÍB …²çš¸>¨ù¨`N}šl_‰B¾.µÔRµ`(12æŽ:ꨋëöê7`Î;š®yö˜—ò-£ø€LCàüñe åu̇²Y¬PÆã€qÀ8``Þÿ¦˜3gNAÁ%y”ëSôç?ÿ9‹ch_pÁ©¤…k±ez,ÓìFNÓ힎ò"W¼è¢‹²M6Ù$ÃØ…º,³§AÖŠ¼´L PØÄö¶¡;önÁæ‡zȇC¶xØa‡Õòè…€m·ÝÖ‡¾¤h´Æbg@l8WC- –t¯‡!ÓSO='³ßä€æd¶½Ê8`0Œ3Æ 0<ŒÐEË¡‡Zh>,±õ¾áCŠ4î¦Ó#@uHý̱R*î؉WLXŒáv0«ŽæcXÖ^Ï«óÐM=¼&€÷¹çžÛÂså% í2—Æ€J;í´“÷ ».ÌÙtB1ȧåâøä“O¶dEÛ‡iôœÅrŠÊ\nãJ¿ŒØœ¼ôÒKþ¯,M/×SÖ¤Ÿüä';Î’rsÌ1ÞÖΔ¹.{ì±-|¼ôÒKë>^;Ý Þ£ŠûÇù矯·9¢9­}÷ÁM”äùå/9™›ìû°ñÇU\¼éðÁó²‘ÀSœF_pÛm·Ò–¹žë0ç}ê~Ž2.§›¨+¡.´ 8·oeu¥Î€å{ ä‘GÒÞzë­…üP^HQeOåË5 a¶Ùf›dRæÜñè†JcÉÄ5/j>ª ˜7Ù¾mB¾"`Úyç³—_~¹”;°V`­r÷ÝwÒÕí+<Ô `‡5ˆ-V´PM×|ë¾›´ðƒô)bý ë´½à•Ð«c!U¾N®`Þ ·,m?8Àžä?þã?*ÿºÜÇåå›Ûî](dµ#æã[n¹%;ýôÓý·œ= kÆø]Gp~ÒI'eÏ=÷\!K¾ÍíÊÑíý¦xU(pðcÛ+(~Ë)a‰vÂvkIÔæÂ(·g›ªÙmã€ç€æýíX*³ÿÔõ$ÀëX*ïÒÒÄkêuÖYGo•Ù»ë{8^~ùå…´?ýéOý¾p±‹Ì‹ï`€gµk®¹&â›ý`¸Ïî4kŒ}Ô;@< õž3W_}up㯎e>{$Ú™êO<‘¿2–¡ PExÓòÃäýþnW•Çîe™æÖ ŒÆã€q  `¾ÜrË{áÂoÆŒmë×Ð +@IDATÊÂ+ÂP+<âx=h1â2(ÌŸsbl#üŒiµÕVkIK¬žgÅ/$„'qžú;å®wîܹ¥éÑn ÍEÀòp1@ƒP™{ƒ&¥Z·øˆe'0±ÆkxÍS@g„QenÙ±’ÝgŸ}¼VgX—_þò—,§m c÷Àêv?.Ãg?ûÙ0›¶ç,öã<ô7ƒ˜°8Óûá7Í)*+gè&:|ŽE>€ ›$þÚ-ÔÃgëžã:,;çôõNˆ1‡{au9L«N”7ؤÄeøÆ7¾ÑIj¥Ô{´01ð¸Ë.»è­FŽýÌÑlGÁ%EÑ,×6KÅ'ñÅóû¤cÎЊ‰þ·é¦›Ò²IŽç>žë0‡ÿ€ï¼Ÿ<¿ùÍo^¯ s/uÅ6V¼Bãž¹á•W^)¼(J…'ºBwìÜ€V¾r$åTbSOx&Ê®yÆÇX©‰ß1!!.V¼(تó=è•5Åý%Ÿ5Ù¾,¡åíKÿ„¼'ü†3§"ìGŒ²íºë®-J uû õB¡!ìWœ§Ö9)  ŸÅŠ$EM×wÔ}7i;áéSÄÜvâ‰'êKÝQ¼)zõk,¤Ê×É5Ì;á–¥íøv¬¿þú•M)G"¨n÷.”nËE6”ÝXk³¦Yb‰%üš–ùÅ5ð„PamʼÄzŽ5/½B:øàƒÛ–£]9ËØO¥öjÇöø¬MXß±ì–F¹=»­³=7¹8`€yÿÚû¦›nòß]C³÷~© 3 C»!« íƾ9 +Ä9VÓý&ÖͱÊn߉ Pyµêª«–®»ËòG±o82¼ü!wÀ"¾ìOAÿý÷ß?[tÑE½§¬P¥åÅ_¼P¦p¯—c÷ÝwÏÓÒÖ(M, 0ŸXþÛÛÆãÀØp`sÀUµœÖSxlËæÞ{ïõ‚e„aÜòˆ­’i8¼EÂwpÎ7$¶€¹a:„‘010¨0­ž§b–²×ûñ¡~HlúC°œôhªâ6pKåí·ßރˆ[qÝŽwPuèáûÚã‚»,ŽVh3gÎ̦M›æÁª7ÞØ[]'e‰ëª¿qÇ €€ûÙÓN;-›>}ºÜÙ(`¥ŠÚØZwÏú|xÄe}™;U·+¯¼2™y†®œõYØáûôüo|cR£õãÿx2=±¡ÙŠB„æûÞ÷¾7ÙSÏÖ½†°Oó×#šÐu6?XÉ`  ÅAT÷õ>]h¬e †UÓ4¨÷h¹5Z'ø÷]MÛͱŸ€9óL• b”<´^„·ˆ‰qƒƒ«¬²JvÝu×ùyˆMÿyç—¡DÏ­äË\‰¢ }L)Ìq•ŒP4E¸§A}<„ IAç^êÊÆy‡vÈy¡<¡î€Ìc¸Èíe`f.cžK¹ã‹=”0¿*ÐÀÉ÷aÊ ¼«—²‡¼Ï?ÿùÏçõÐ}6R #-B „Z_¾‡XB×±à ߟj>Šã²^H•½Éöe­€å™Äù†£8‚5´/~ñ‹Þm"õ©Ê?”ªÂï¹î·õ½ìkð6£eBA~Þ¼yz»pd!§Ô´ìùC…÷Bbû10`>0VÛ‹ŒÆãÀxs`¢sHnq烕ZË Â@\~b¢íÄGxm¸ÓÑÅŠdRÀ à‚Ð00Ï°€R7{,vm5/Ž¸q¥‚9,l±°Ãz0Lžø"„çp ÌÚšçŽ>úè‚»V¿a~á9È,ÈYÐñØŠ–ð€Kk¯½¶ÏSÖ›Ýôn@ÕØ’_ËDy8Q&À#Ü8+\èÇJ ú,‹](3.q¼p­ß”Ø4`‘jsžÄ$Eã´jÑ ?pÇÇœÖòpøÇ­}†2°0®j;”4†ýï)`¼Ñj½ë®»Z›Ty®ºê*­~OGêhÄæ"¬'çð À†q…Å –íð™#ü<üðý" ­ 5,#ë¨øyòA9ž5!HÔ{RuF@«|a,°¡kŠú ˜Sf” hóxîÄs iÐ`Oy_ Ž±;9„x™:uj†æ8ó.טÓã>ÀFÏ„rPbÌéF˜w3ã%„os ÛgEðM¿¡o2/?Ö¹\Ió^ë øŸš ˜ß˜Ç0—)`ÀœÆ\^ІJ” E ¾(|0RÀsîõZö˜'Ì…‹-¶Xž7ß³”ò ßZ}¿i”ø©ßƒœh÷”²ÓÅ_œThi²}Q‚ 9”wYû0ø(ØÉÁBþÄÄw¨N_áû Ýx<( ¢ïâÙ-·Ü²ÐÖŒ)”WRÔdý:}w]~¤Àþ¸.|û´m˜ëP,£¦ÇBÙ{:½®}(5~;ÍËÒºác˜u:{<Özá÷[Çß^`Öø -´P>f5oŽ¬7ðÂÅ å5‡yËqÖg¤ç»Íº‚½k~¬ºYÓ²– Ýêê;PŠ  …=ž •Ï4=ïa]Åž7þc^EO¬ZælÖç¬ÇõÙ«¯¾:|Uãç£Ð^u+’¶òo*mÒ r{vS_{fòqÀóæÚœýòâ„us¸—bȼžò;+–sQV”Ùõ¬;š”÷´«¿Ý/ç€æå¼±;Æã€qÀ8Ð& 0ôF %´¦ÕEG|D(BZÀ"‡€€UÏ®¸âŠ¥œ´@ ½ùæ›ç. S;XhW;´zxìˆc4ÚàÊ:L—&–XåòNÀæªÅ€ 0]À¡=çÙéo„¿žáB»”95nàVñAåÆ•pHX"*r…õ‚çXš!ÌQBŒîôñ9<Ä•"–{e„Ò}$LÅùv¡ð€à y4±UÀ§å7J€ì¡R€š>Çæëó8n4eÖ4Y¬‡ŠeõiwkW6€–eÊôUÆÀkøÌ‘ß´)ýœr‡åãKœvñ«Øhl»í¶Þ7tæEÞð àa& Ò ÞSU.6Ç!¨uÉ%—T%ïè^¿sÚƒ6ÇšMùÙ³gûq¤ž—(/•2(•…! oÀA¼( P­Ñ2`m{ÜqÇÜÏ1Wã-#ó€Ïða½õÖósõZk­åû s8 õ©§žš+®ÄÌ ó^ê ‡;X¬èRc"ì×(c¡Á^å›pº1×gùN7xbº5Uö˜'ÔCëÀ;Ë\À¢9¯e ³fÍŠ³lû{Pó^fð~%a(ÈÒò3ñÍ Ý6ݾ(˜PŽªï Â"Úš9¬ à­ê+¬i¶Øb ?–Ržt˜ßùF}å+_ñã8l(ÞËuîÇÊ,ð‹5¤”Š^ë×Ë»«ø¡c'¬gÙ9ÞŠ´_´³Nlr,”•§›ë˜wÃ5{¦_@+\³èøâÈ:…·n)Tp óåüüóϯ̖ý\¨ÌŠ§.”]ã=ßlÖ¡Ì#ú$ªË(å1åƒü _#Sßøµ>kö(a£8­ï+³l+{/ׇµ½êÔ‰8½ª ¨ýµc¯4ÊíÙkÝíùñå€æ½µ-ó5`/Ö㬙‘§êú oE(…³¦l§ ZV Âp±¶Õ}227ä¦(Rzè¡ÞÀAeLÈø0è‰e”eyÓu¼Õé|œ!–V•™’ò\óèôXåÙ5$ì‡ø#ËŃ'rÖ´2AöÍìe4ø;Š!ÁÈ8`0Œ=q@'N,©œÄctâB¨§¼:yX6 N„<ÒqZqwêdaSúœFœ¸9±”v̶< EqÀÝrË-N@ ÿ'Ú´><e'ÖxžçP;ò#JN”ƒœ(]8Q")ŒËøý"¸tóçÏwwß}·“M¿!¬cþane$'·àΉ€ÁÏÌ̯"ðéÄ¢ÚÏ•š¯‘ãB<~ž¦|b]îDIà HîŸ%' ONÀi'z'J9úxáØd]i[ÊÂ\&Bn' AN6Øž_Œ þ¨³(@9Q pôÊþ% ß–¢ŒàDC݇DIÀ‰Å”Ÿx¾É²‡ïæ;)I¬ËXDøù^8²gãÛ’(ªºx ¼TyΞH@Ç·bîܹN¼sU¦oòæ0¶Wú‰²±7º…¤ì¯ØÛóÍê–F½=»­·=7Þ`\ˆ§‡œE”dÇ»²}¨¤~n‘ÐG^vÈ:žo{YöÊš;ñšÖÓ›Ùã²emªò21¦ñûÖzì£y—(É:1Æñ{èž^8³A– !3OµKAz䑽ß Ú­ŒY"cŸÏžöf„,5 í,Öÿ^VÅ>® 9OYYìz}`^ŸW–Ò8`0*80Q€9‹@}ý$6È0íà… 1åAx`:àà' ^€àÔ"ˆ´,žêy@uÓ³ð bQ†`G\:±R¬óªÒ4¢…Zz¿“â6Û/à\ˆ¡ Àâ‘zjÙËòC  Ïêó F]QH¸`ãAÛÅH½XÓÖ ìW½ŸzP”ê,äÙô„Â5ÝÔþÀOò8ï•(;@H?ˆr¶Û2ÎhçNˆÍ c°Ô{Ú•‰q!VˆN¼$ø~’@s¯ö+ú&Á^‰q‚ cƒ¾`Ž‚ƒhPûqɘl×ÎZúùЧ™S™Äê5cÙ$3ÞÉ“wWed®`ž¦|Ì!üÁ¯ÍÛ«¨u¥.'u,'5Q Ò:õ£ì(4 DE¿¨0-Ц”´©x!ð€@€@'4¨ù¨î7šo c)þæP§¦Ú—¼Xch&_øÈà[Eÿ引õÆQÝodü}¤<äÛŽà‘¸)N&ë¶~½¾»Œ:v’….ŠU¹WAÑNµøy%J’ÿlr,ä™6pb€yL´,åJXì_R„r-Š”Š[âÅÉkù¾²î 6„±n@ï¬çíæ^”dŒ?ùä“^)eó‘Ê¿!ÞÊwBâ‰Ç#Ê´ÔU,Ú;y´§´ÃÖ^u*Ãü&ë“X¢p°Ã;„—;:õö쨲–xÒpÀóÞšåuÖ»ì_uï)žø<ˆÝn?ÛÉ›QZåeì5Yƒóaɾ|É%—Lî]:yÏD¥E©™}Ĭ®ŒôìuØ÷Bì±1¨"ä°OáYû'ýCFX¥_•·Ýë 0ï_-Wã€qÀ80é80Q€ù°2š…‹S@O6ÚÃ@æXÈ–«& ʲE%éÙà¼ÄÖ¼âVÐ[~C½Â2°0‹¨+v>ê„Ær/ X I,ʶ³Q¯³•t8è‡ç“ /¼Ð÷K àAðh× ‹”õ×_ß+пMXsÈ~Pw‹^)Nµxe§ºå¦±`€yÝV³tƒâÀ.»ìâAK”WP$ Ü(D¢\n§ÊȾï>ØVãY($<ÒH‰ðR~Ž•˜„ö*”o)Œÿ*¢ÜìïFÊ”‹P4È©À ‹iø‡—šAÑ°µWzŸ{î¹~Îû–>‡&Všì뻡QoÏnêlÏŒ? 0ï­1~a¯ÄÞ£AÉ Ù·A&/ë­ýzyZåÄuöʽ¼Çžíž˜wÏ;{Ò8`0`0cHOq•Ë¦XF`Ù…»v,$R„À‹y‰ëî¿ÿþ<à ‘qÀ8Ð0q¥†u J!¸é—x]ý±½Á8PƒX^²OÃÛŸÇ‚þT6X¥ïºë®^ ×ê;w&#•Ÿ]3L4N=õTwðÁ{K!Ée뫸œÃ6 0[È~O4€Å æØ59k" R§¬¸FÝl³Íü>¯Y(lÅVêU€9Öç„m i»í¶ó ~;PKvµdF1ï615°²ß{þùç½Åbl±¿³ÉßÃÖ^íêÆ~PÂûàq€ðcJ„w"ôÚ§?ýi½ÔÑqÔÛ³£ÊZâIÃÌ'MS[E“"€32ŒÆã@Ï?¾l2‰aÞs^–Aó-“8ê¾h'þÄ T&Úm_F±†(<+1øÚ>g ŒÆæ8 .Û2±XÌÈÈÄmZ&®I›ËÜr2tɉ)›‰u^&VÙa‡–‰‹ôZ9‰5m¶á†fâ¦?ûò—¿œ‰úZÏY"ãÀ0p€usrH?üp&nýZéÀ oUžãXpÈ׃µ£‘q`8 U¾O `™‰“ž„=¸”Í~ýë_×.ꦛnêó‹uÿÜ6ÛlÓ’§æ¥ù‰;ÕL€ûÂ3âZ5;å”Sjí­àÏ$LR&aL’ï´BÞÔQ,Ì“iS%^j& ©[¹6líÕ®ÒßûÞ÷2q©ëy~ÕUWewÞygKûŠ²x»lJïz{–VÌnLjüèG?òcFb˜Oj>XåÆñã.„ŒŒÆã€qÀ8Ð3 0ï™…}Í@4ç3±ø+_Î8ãŒÚï\W Aªh×~ÖŒÍp@¬’2±`ÌÄm[&q¢3‰I™Iè„f2·\Œrà[ßúV6eÊ/d>äC2‰ûY+‰3—!\“¸ìÙ‰'žØÈQë–È8ÐGˆÛæLb{…‰œvÚi™„#ÈÖZk-¿N¸“øĵJ0¬cÁóZÍg‰È€—ìÙ²Ë.›ïKt"–âµJ$VÄ™Ä÷ÏK8¿Žê0—¶™xêj)ƒ„¹Ê:è ¶J`7Õƒ²±âV W€u§vòŠÒšß ÃÖ^íê/¡Æ|[²¶f­-á™x3(´¯XègUJUïõö¬ª›Ý›¼0À|ò¶½ÕÜ80î0À|Ü[Øêg0ÄÌÄè._ƒ`« *q”Ø{ZôøÃ’¹ÄIŒ¾lÖ¬YÙÒK/íŸÅŠðè£ÎÄÅ_ò»h0ô—¯½öZvÞyçe‹/¾¸—6ûËoË=Í®ðZ8pöÙgg/¾øb:aâ* \âÂ=Ã:]â·&RØ%ãÀðr@â{Ϭ£PD\b‰%2‰œ‰f¿N´®eö°Ž̇·ÿMÖ’…,<@y0ÜÓp¾ÔRKe¬‘ÚÑ>ûìãŸÅcÄ÷É;ÌyHÂUµ”r,¼ðÂ,Ê5Ý*5ö°â±…5"JEÃØ^e¼øÅ/~‘†ÓvÇsLžŒµvÜÇ:ñ’g$'£Þža]ìÜ8 0À\9aGã€q`Ü8`1Ìedd0Œ½sÀb˜÷ÎÃ~çpÏ=÷8±Ìc‘P'îýqÁt ,°€û¯ÿú/'VON÷îÙgŸub9èDåDÈä¶ß~{'Tý.®åo0”p€ñyï½÷:qÑîž~úi'®€FKRÛeã@³ ±[e•Uœ€ånï½÷öq?ÅmG/yá…üwD\²wôœ%6L4IJ{ùå—“ÅXo½õÜå—_îã'$.ãX°扆²KʉM éÛn»Í‰+s·òÊ+ûý‰L”zýºH¬ÆõRË‘½ÍJ+­ä$|ˆÛ|óÍxJq|‡¶ÝvÛŽb˜“1y0î×cñ‹Ä½·Åd·Áøï${­N¨Û˜×ÄG ß|òÉN¼9b¤O c{•ñAÂŒ9ñ¤æ×Ñ>ú¨(ŸTúò úŒ’("8â6wºõöÔúÛÑ8rÀb˜‡Ü°sã€q`œ8`€ù8µ¦ÕÅ8`0L  0Ÿ@æ×|µÄÜt?ûÙÏÜ-·Üâzè!'ZÁ^àÄã€mbQäÄBʉ5º#­XH9q™ëÀ‘W\Ñ}ä#q -´PÍ7Z2ã€q _`|Š?†×^{m?vûõ.Ë×8s@â{z1JWoxÃâÛöÛ80¶P (® ÄDvÇ{¬Xâ{£öÛóQk±ñ/¯Ž;ÌQÜš9s¦/X…ʳOyðÁÝ›ßüæÂuý!–éN\¦;”†ÅÜ‘Ô `Îs(,ŠÕ±C)9EbmîÄ ›éN¬Ø@zJ¬âíËí¿ÿþÉÇQ¤ëz¯DÉï•W^ñ{»ȧ¥½bæ¡`€ ã׿þµoŸyóæ9/”h[ »¡?}¿9óÌ3ĠϯÕ9õö¬SGK3ù8`€ùäks«±q`²pÀóÉÒÒVOã€qÀ8Ðg`Þg7˜=óR8"`Ñ?6óXY`)ÈÂ&€ôw¼ãn±ÅsX ŒÆã€qÀ8`˜¬@Qéæ›oöÞzžyæˆÅx³Í6sË-·œTF7˜z Ž_ùcÀœâa…^qAžWÅ_¼rÀó>2·Y# @È"q4½€­z2çf5ØGÆ[ÖÆã€qÀ8`0Œ$þð‡?x·ì€Q(.ºè¢þo$+“(´æ ¦Ø¥ å@ 0Ç#Öî»ïîæÌ™S(À4à'àyH¸_ßn»í¼'­K/½Ô‡˜ÒûÝæ<Ï^êÉ'Ÿt·ß~»;묳ÜSO=¥ÙŽ¸HlÅjy«­¶*Ü‹¤V‰³íâ´¼_Ár”Ü6À|XÚKù‡§&úÊ<à>ñ‰O8<çÐF!‘·û×_}~™~uÕUWy—þùÅ6'£Þžmªg·') 0Ÿ¤ oÕ6L`> Ùªh0ÁÌÁe{‡qÀ8`0ŒÆã€q 0À¼¼µœ»ã@ 0''¬»±ÿë_ÿšgLÿ½ñÆswëÜÀò{uÖqwß}·#”Èý÷ß_1Õ `®/F†ÐWX¸_|ñÅîÏþ³Þ*yÿa‡ævÜqÇÂõðG `ýèG?êó Ó鹆Ó"Þö)§œâAàaÌ)ë0µ×~ð·á†zƒsÎ9Çí¹çžÊÎÂ"o¼qáÚzë­ç=à= z{Ö©£¥™|0À|òµ¹ÕØ80Y8`€ùdii«§qÀ8`è3 0ï3ƒ-{ã€qÀ8`0ŒÆã@Ÿ9`€yŸlÙwÌ2ÀYXk_wÝu…ùdwÈ!‡è-l0'#¬½Ÿ{î9wï½÷zks¬—Sôþ÷¿ßüñ>nvê~ `ýÔ§>åóM¥×kXDc)½ÑFùÐZÃä’2S{í°Ãî²Ë.sï~÷»Ý£>êÃ)Ã#¡ËÖXc ¯ ¡×X`wÛm·¹ÕV[M/UG½=++g7'- 0Ÿ´Mo7Œ= 0û&¶ ŒÆÁpÀóÁðÙÞb0ŒÆã€qÀ8`è 0ïg-ßn9P˜“Àåg>óVkþXW³Ú~ûíݼyó<( Èóž÷¼G“úcS€¹fŠ[ôÇ{Ì]sÍ5ëåßÿþ÷z+?N™2Å»Ž_l±ÅòkzÒ-ÀÊóXÛìcsX›`Nù†¡½~õ«_y÷ö¿ûÝï¼ö-¶Ø‚¢•Ò-·Üâ^{íµÂý]wÝÕ]tÑE…ke?F½=Ëêe×'7 0ŸÜíoµ7Œ3 0çÖµºŒÆrÀó2Û^e0ŒÆã€qÀ8`è 0ïS-Ëž8P˜ãúëñþð‡…wLŸ>Ý]pÁî駟v«®ºª­÷Ýw_wæ™gºØ•vÓ€¹äå—_vwÝu—·hÇò<¤ÿ÷ÿþŸ;ñÄÝÌ™3ÃËþ¼€• pù(|å•W¶ä=ˆ ÃÞ^'œp‚;òÈ#sV¼éMoÊÏS'¡Ë½¿È"‹¸‡~Ø-½ôÒz©ô8êíYZ1»1©9`€ù¤n~«¼q`¬9`€ùX7¯UÎ8`0 Ž¸~{æ™gÜw¾ó‡Æ¼‘qÀ8`0ŒÆã€qÀ80ZX~ùåÝßþö7÷‹_üÂê&šU,e»âŠ+Ü¿øÅB14|ðA7gÎL¿å-oq=ôPrŸÚ `þÇ?þуàXµ¿ùÍo.¼3õkó[o½Õí¾ûîîßÿýß IpéM<õ˜zXýë_{÷óË.»lœõ@~S{ÅÆÅ:ŠþÈ-VYeG<ò:tûí·ûþ¦=öØcÝQG^Jžz{&+e'=e°õÖ[;æ™8,ƤgŽ1À8`i`>ÒÍg…7ŒÃÃb{=þøã^»ßóái+‰qÀ8`0ŒÆã€q .ÞùÎwúXÿýíoÝÞð†ºY:ã@ß8ЀýÃþàÖ\sMï=,ÄŒ3î´±îÞrË-Ýå—_îþþïÿ>LâÏ;̯¿þzw衇ºÃ?¼¤oÉøõ ÄîÆÚ}Ÿ}ö)$yÛÛÞæ]}Çeê`-¼D~Ûü7¿ù×ýÆ7¾1¾Ýøïaj¯¸r(W¿ü¿ÿû¿ÝÅ_ìÖ_ý8Iò÷=÷ÜãÁÁð&ÖåXÙ.¸à‚áå–óQoÏ– Ùã€pà'?ù‰[wÝu}B`ŒÆqá€æãÒ’Vã€qÀ80Á0—ìÜözã€qÀ8`0ŒÆã@0—ì=2Ðoœ ÀÎ`離ٳg»ýöÛ¯pká…ö®Øñ”ÀsS§N-Ü×æ7Üpƒ›6mš~÷ÝwûØšOÕ‘8æ(•¿ôÒKy2\Ãcñ¼À ä×8i`EQà¼óÎó€=Šý¦aj¯°®(¬³Î:^ÁÉ%—tXÈ.´ÐBa’ÒsâÁò“ŸtO<ñDž†~EówÞ9¿–:õöLÕÉ®Ì%»õã€q`\9`€ùˆ¶,qšÐˆìáV*ÖpíÇ{,ωçÀ /¼àÎ>ûlGl-\ï¡iûŽw¼câ f%I`>’Íf…6ŒÆã€qÀ8`0ä0Àõ)wï½÷&K…»s\l?ÿüó-÷ʱ4/s¡Þ `N¨‚å–[Îa©}á…ºwܱå}eV\qEo•©÷ʱŽåoM¬¯½öš·ýÙÏ~æC§m¾ùæúú¾‡©½ÂJ¢4±É&›8ÜäpÀî´ÓN o·=?å”SÜÁ\H÷‰O|ÂðU–û£Þž… ÛãÀë0Àܺ‚qÀ80®0À|D[öC),´›¬Æ 'œàXô?öÝw_¿ñDƒ_ûï¿¿;ðÀÇ¿âVþpÀó¾°Õ25ŒÆã€qÀ8`0 Œ˜ŒÕö¢šØtÓMÝ7Þè•üþóŸ—>…›ô“N:©åþ•W^ÙâN;LôùÏÞƒÉá5æ|ä#á%Žì«dܬœûÛßö1|[&.,±ÄîÅ_ÌךּêªîÈë ÖÌoûÛõ§?bÝ|ß}÷®µû‘e™;î¸ãÜñÇïÃ+Ûü]ïzWþïyúé§Ý›Þô&÷|Àó›=œ S{i5àÊÄZÜ~øá‡ÝG?úQ½]ëˆÁ Ïüîw¿ËÓÃ;òÜ`ƒ òkñÉ Ú3~¯ý6ô“˜÷“»–·qÀ80‘0À|"¹ßû/»ì2¿°f‘÷ÐCõSë£×^{­ûÜç>×zYf÷«_ý*¯×j«­æî¿ÿþü·:á€æpËÒŒÆã€qÀ8`0†˜_›Löa9þÈ#xoxÄâŽ-²•?È6V^yeï†]¯jc•^gš8Ö·Ýv›>â?üáÝꫯ^¸Æ€×ú§rÿöoÿæpɽᆺ9sæ¸Å[¬%mxòc!ÿ·¿ý-¿|úé§{£…üÂë'³ï}ï{ —;•Õà~ ê3Î8û_i¥•¼ì2C=ö˜;âˆ#ü½7¼á î}ï{Ÿ;ì°Ã’J…‚Ôø1Lí¥Å¥=7Úh#ï^þà?pÿðÿ ·kiûí¶Û΄|æ3Ÿq7ß|³WJ¯ëù ÚSßeGãÀ 8`€ù 8mï1ÍÌÍñ†Þ÷Ç?þÑñ÷Ê+¯¸“O>Ùkµ†Y³ðûÚ×¾æÐ`‰EÞ_þò‡f쫯¾êî¹çwçwz·D¤½úê«Ý¾ð…ø1û=†PÍ_­›=\•ºáÀDæ˜ÓúIo}ë[1憙ˆ§†å‚"\ï¡9Oˆ„FŒõ”Þ¡tõàƒºgŸ}Ö —ø6üã?þ£·œÀªb½õÖsÄxEÂÝ^(”*«‚#ˆµÈ_ÿúײ¤…ëásá ¾³ÿùŸÿ^j9/{¶%á_À$ý‡µk’óÏ?ÈK<˜â1Ž,tN‘×ÖWŠü·_ÌZw¾Sÿó?ÿÓÑX$)s©«ù¦ŽÝ–àÐÈ80Ù8`€ùdkñá®ïsÏ=ç-ˉõÍ7€¸áX[§ˆoÊ^{íUX"ûçþçTrýÂ?øÁWî¬iwß}÷äsì4–:²7â‚ã2e‘NÈݶß~{÷ýï?Ïﳟý¬ûæ7¿Y°øÖ›ßûÞ÷<¯¿9¾ÿýïwO>ùd)(«iáû;ö…W]u•CÁ:蠃ܬY³4™ÃÛà¹çžëØBXJß{þüùù¾(OÜÁÉ0¶{»-¶ØƒÚTeúôéî‚ .è Vÿ—tÞ¼y¾-ÿïŠóqì‰_fx4ˆö ËcçÆAp`ÔsÚÝzë­~{ä‘GzË GÜûÊW¾’Çfca…" ‹¶a·²×úrDqáåÆ cŠ¦L™âG(™!ø‚pȼxÍ5×äá³ð‡øuK‰¶ìŒ3ÂÛþÁ Â=xùÝï~×ýéOÊÓ ì"Æyè;ó›#r‚R€9Lè7› ºÊ#RÕ®‹i¡sþ—uÖWºîB#÷ !}ÐògOÕf)âÅÈ&Ÿo Bâ·V…™Â‚k>æjÑ(CuJÝ–÷­FÆÉÆÌ'[‹_}± W¥^„âáZpA/à4²0 á;Á~¥§SO=µeÃ÷Šµ‚vµÜ óàð˜÷ð½Z~ùå ÊZä‰Å6€=ÖéìØ—¡LË€6å¤Ü¬—±òP&ý§?ýi¿GAfî­ØÇa=ÏZš:+¸–‹<ȇ?\©³ç!oêÍñ²um®Ïò ßå0.úÞ{ïíÁ_M£G¬Ð©['4¬íuñÅ;â׳Ơ­•àãÔ©S½GÎ<ÐÇ¢×{©#Ày ,ŒRBL(UÄÓØ"‹d{Æå±ßÆ~s`sÀCæo¼o0?c@²õÖ[{å!ÛÇt×cøþ0×bd„€oŠø^±—#„›½X›ÓvÛl³•ùÞñ«c(“*×0]»ãŽ;¼@ù¿‰âý¹#{göÀ„jy×»Þå×%¬bzþùçýúãH<¢`·Ç{xIöè´²ÑEYÄ{êAùüC‚Ÿ7ÜpƒWÜcŸÎ^˜oÚ¢‹.&ûsÌÇ ‰Y‡ _ª„Æj@PVe,pIEF£É´âXô³P·xä£Ù†£Zê‰̱8­yY,¡=¯Ú÷,XLãr)$À\Ò°ÈS­ü§Ÿ~Úkœó[‰ù”yuØè /ô€9šƒ‹¾úÕ¯zá _úÒ—r·s”€–EÔ;ìàO,ä5„º$G8ó­o}Ëí·ß~~ƳX,¡‘8*ÄBÿò/ÿâ7EqÙ©;‹Oê®BX€³Üe—] –§Ï2çñ á;³óÎ;{붰Ö̳h¼£ϼ‹ „ïPÕXáy,ÃpsÊó|ãù딺-_Ê[W§ï¶ôÆQã€æ£ÖbãW^¬¾±úcMTF€Í¬ËÙ³ÄD¨ òÀKú˜ç;ßi±*Óñ›÷°^C°¬¤ Û(Îbl‚w)¬Ûf X'óÝøÖºS,ÄUQÚ­Ö)/{NöMBvÝhÞ¿Èþ(3ßnÊ a‰ ˜Þ k{±WAêG´+{9¬ùÛy’c¯}衇z¥äUÄ~ðmíYU&»gèF 0Gƃ¬œ¹Ÿyo(]!ãêvŸ`û˜ÿýf`t@[‡Ÿ¡Ì†ÑN·ÄË7YÁùQÌÆ‘aUŽVâÈ`±ÈGfÍ7¥óH®<„„‘Áð‡¾¾”÷à o2ì¡ùÎcÐÃPG…¥9ßIýBâýÈ (†!>Ï:묑•_†u«{n€y]N q:B,Ìé0Ç"“ £Ñã:ah0ãBÌóÑkÃQ.ñDæÄ~c!QN€å,šXðdž˜ù Å L¿ð…/øM´jå#ðg±‡•µjã² k€a"6ëhª+Û›o¾Ù O ¡ „7XGà>‚…)„1ð ¾ÄÚ( À›£Ž:ʃæ|SXTU-Ðô½ÃxD obwásEÁ¨Ì£ V"Ù5CÂq’èSu-N€#À‡iÌosÈþU…ö ï±9dA²…’æʉâ1:¥6¼ú¤úB=øËœÄÆg”CçX_)ö…Éò‹>¼Ï>û´X®1_ ……AŠRc… >ßb‹4EÝ–¯©÷[>Æaç€æÃÞBã_>,¡0 iG± —gX?¡¼Åž0õÍAAeàºÄ~á³ ‘ú¸áæì«È“ë_Ó±ž œ|ψ H›¢ºuN=ÛîZŠO”5&ef½†ëU¬Ð‘)aýÞ Õ-{ª¼§_íEÝÚY–rWü!ÌP]¢¯Ð¿êôáºy†éÊø¦±sã@¿90J€9s2²1d3È qÇŽ¥3s{LÝî&ã>†>€";È‚w—[n9/ãà ø‹€pHxˆA‰ºìé. )¹ÝvÛ¼AŽ2`ŽÜmæÌ™^É å;YžDñ°ÖN¡KùzÊ)§xË}5üB!9d,Ãeí‚·KÖ(܃—ÈÔc%>Ö5È«0º"&=ž{ÍùþL ’‰ÀhÄ9 ƒµÛŸ€×J©™XVfuü¬=0ñÍM&®-ó~ €ùÄÊJ0©8 ßÿDm õ-xÿ^±VË4ÎdóŸ|¿X_çãCçL‰ë’L+›âLÜ4e²yöψB2ÝD^w=yù¨OÌwYàd?ûÙÏ2Ò hžQ'YÈf"TÊù nsK« ÂÏOY¾n²É&¾ˆQIvË-·d/¾øb&–ÌþÛ'ž921DÊ$‰Zí옌xFâÕf¢)•DQÇNù#š¨™¸nòuë½L,#3ÑÆòå <©»Ä¶È$†s&ÚAù¤'n7¼ò üUñ“¶+ÕŒ÷UmŸEC¬P>ˆô ÚNÜÛx®Û¶àxß}÷eóçÏÏÄ…­¦Ê&úª²Ú½Ás`¢sѤóýžÅZÕ˜í0‡{Ì­(žnž…@,eDᩉ•y&–Ñù'.¤Êi¹.ññüóbÝŸÏå-‰†ìÂœ9s²…^Ø÷ÿª¢‰Õg7˜§¹%–->ѺQl”°9>ÑN¿hˆ¯Z_âÆéSÑP¶Ò9S£òm©±Ò/!\7å«,¼Ý4Œ 0£Æ´ªÚp@â¯gìW’ØŒÆ:ÀÙ2rö#bq›‰ç‡¶ÕëfŸ0Ùö1<òH&S¼‰„¾ôJd)Æ‚a€ñ ° {BŽò o¬K¤Ýwß}=îñÉO~2+õ<¿QÌÁ~ac£|AžvçwvÄø˺‘U†<úNŽÒ´ô´Ÿ„$ñéáù¨UÕ¿Î=ÌëpiÈÓô˜€K,„LÜî–Ö !qcœm¶Ùf~!-.3q‘­°Â ™Ä;ð\\×kø0¡u´ÿþûgk®¹f&qœ<È%#Öl€¼\ûèG?š‰[$.n†3q ‘‰{äl•UVÉ°<—æFm”I܇ښ8ÑX§N›6Í×…:iÝÈO\GúMCÕ• üW¾ âú8¡Ô‘ t;X×È™ÄÓÍ$—¯ÓòË/ïóW1™Ä¢ð x Ü¡y/ÂI–  &=ýwÄ- ¹¸Õȼ£Ù…“¸åh)¦‚ä]t‘_\ÀxˆÍ=@mq3œÑ/h;4ËÅͱWhɰ䂸ómG]¨?íJ^Já-ùö©" úשRBIìr˜(Àü¸ãŽóo‰ÏRYƒxÁ8)³0׌Ž>úhŸ·¸nÒKCsd¾ 9Âíhë­·.<ƒvád!Àoq5X¨?ü“˜{•,Й¸'*<‡öfo,|?Y¼óF¨ïûßÿ~_ævžJ ­×¢½¬ÓÂ7àÙ@®ÔRr Ÿ†së+ÃÐ ƒ-ßÍðŹ„¸¨,DSc¥ò%¯ßì¦|uòµ4Æqà€æãЊVã@{`°‚ °y€‘qÀ8`¨ÃQ̱¼EÎÏ>Àƒ´:ÔÍ>a²ícÀ‰à+Æ$í æ]%vvaoˆÁíS—0ÐèxÑT™eEÀZ=šRøqÎ9çdÊhéw!/È‹±YE|ëá%iùCñ!öX>÷UPÀ[Æ¡ãN˜A ÷2)_rÉ%~p°8N``%Z.,¢s™äH 6ÓX+2aM­T‰Íš´¨f2x´P5‹°î“8àÕÁÊ‘÷¡…¤„…4‚6ø¸«LH´W«AÊ \mQ¦-·ÜÒ»l^wÝu³/}éK^cI?Ê°Ì2Ëdç7éÎâ²Ë.ó ¸ÄUÌp ‹}‰ý›áê…2þâÒ¥L{Š þÂÀÓéÓ§{+uøë&òg=ñÄ•%þˆµüŽ‡”v$±±üûà5îñ‡: ía h½íe¾a”CçX_ [rrœ› ir´³Õr<9`€ùx¶«ÕÊ8rãŒÞõ®wyS'ÀE˜Œ““£˜Ï˜1#7~@^_7ÔŒícÚ÷iäh€®uää&±³[dquCbì7eÊÿj3gÎô.;b—q[Žµ9å ¬¼[Ÿ# VÏL¢)âYÀ=´yYd‘쬳Îò1~qmÎFáž{î)Ä­ ‰<Âwr_cÀî#¦ Z&,ù‰#œ"l,÷Úk/¯­CÙùÃB>¨æ@rH¼æXÖë»8ò1ázø‡%6±˜Ù…ñ-ô¹0ǽ:Völ¢4¸qkƒ²–® Àë}Ž€ßð¶ŠñQ˜Ð~„Ò“O>éÝ$S7¬Êõ^˜wxN:£‰çÀDæx'`lµó4Ð `Ž;ròN…4è%¬D7!P¬Ñ Ãù‡ñÀ\ÞW Žz=Ô"dn×ëñEøÊâ—¹Ž¹ S¥Úƒç{ uÑt¯†Äæ 甋Ú-ÔùF†ÏpŽY±¨ÔøJl&ʾGšGSaFºé[”¡›Ð̽!_b—ìh¢Þzë­^¹àÚk¯õkˆn\ü7Á›^Æ«¶Q·Çn×iú><«Ìž=[Ž¬âñÿÖ ÇøžþÆCêv\ª¯tÛÿµîŒÛQ =ÓÄQ4u4ASSœ´|Œƒç€æƒç¹½Ñ80h°·<à€2Ö课úê _oï3FœÃ˜³§Ã¸Oåu<¿j“Œë>ƒEŒùk'ŸR^”ÁˆYWŽ€Ü!Æ„ê(ja4€§Lž{ Œ+4ª€9²¡Ø L¬[\ƒ¸âÚÇ9Ö g¶Ï>ûžÃX¶Šxà<=8Ú  åªÊÖ{G¦ÂP£æ€9NÝB Äj؉ÛóÂ5~ˆ ÐÉàt"Xso‰ &ª?Ü1@IDAT'ÂV'`€ è<½¸du·Õ pé¯É@rÔ:uó4œÈ„çÄ­;âˆ#œQý=PÄðvâ „ù=ø°ÖZkù~&ÊN&x'‚j'“µ“MWžNÜß8QlÈÇ'ô;±š÷ýR¬äÄRwbÕŸ'€Ë‰²„KÍüšXkú>AûAÔ[”$òûv21·üNÀe'N' &¦o¥¯‰Û›B QVi™# ¢¢‰ï@ös“lüø 3FÅ%‘GÆý˜üµŸ’•€v~Î!Ï0ËÐ÷_ÑŠôóÄUòsTôj'‹ZG”(‡€úÓ (ëÇa~AND¹È}ík_óïá:y„ã8œ§Ãç˜IÇ÷A@6ÿñøà$üD˜,yN˜W™“˜oE)Æמ0O,¾øâNBUø:2æM|C$Gáµt›5kVáZøcuÖñߌðß]Q"pÌ›)bH¨ Ï?QòߌT:QDsâzɉ•çýG”|_ žŸgùÞÀ»*ê¥oñæÛDŸ¢?*ñ]”·þt̽²ÑÌç[Q¼sŠ#¿/€¹ÿ~Ë&ÆQgÑ"öëò*GO!þ^gŽè•7½Ž×¼b=ž¤ÖiŒWø]‡˜dƒ’¯ÉÂgø¦‹Âš«áõð¾_qÅNÂV¸ë¯¿>¼•Ÿ³VÚe—]òßñI¯ãºß}¥—þÏzˆµ<…I'›U'JC~Ì`-ÇúK<0ø¹PÇ'}Ÿ9–5wz饗|>¢DâÇýB6þŽy6bÉœA¾äÉ5%ÊÁø‹©×1ç×äox&Ÿ YŠ§(¿ž/\ ~ô:V‚¬ÚžvS¾¶™ZãÀ˜p€5ûkÖ|¿ŒÆñäëHÖïâYq<+hµ2úÆä÷b„çå` ÃFâ*Üã ”KŒ$œ´`eeîfŸ0ìûä–N×ãAÔ[,Œ=R{Ì2¾„×ÅÀƉaŸCºðré9üaß«0$kMäýäQEàb è5Ðç 1 ò çì›Ék fóÍ7/ÈoÀ4À”3 ‹³ƒ?¡< ¬nàiÈ”ë ‡nG¢ìàñ%M®ƒ¼£Œ #Ë'‚A!_[’Žj4â!f®å!ÕŸcŒEsü‡U1`"x+<[˜ËàÍ…5zaÕ²ñÆçé)ÖtXùÄ„Š–Q¸ûVM¬±¤ÂÅ2G4ž° cŽ`%–"Þ‡{qÍ—#y‡$wq®ÖÚ¸dWË«0çÄæó’ÉÊ[fi:â6„÷E ª·ò£Í…4XÚÇDÕºœüRùð ÖX„b‘Ÿ"¬8Ãò ±TEðúá3±…¹>ö1ÖäaZÜ¥cáu[HÒáÖž>š", Ã6Ãm<åŠI@tïŽ^ß°œçÝñûãgí÷à80QæukØ…¹æ¦#=…•è5„îÄ5ÄGz$|DxŸsYteÌUÜ Çš>Ã5îé}¾xÐûá‘ØDí>õê¢Ý;z½OŒîX³•p®&³ ͇ y¡çÄm*#Q.ð|”M÷̧“ CcaFzí[†ö꤬†Ñäæ[3”gX­ay_ö-'ï^yÓÄxÕ:6qL­ÓX'Õ!Ö@¢dâî¤Ò“÷\}ñ‹_,¸âR~¯½öÚÙœ9s¼æ7q*ñ†£÷8²¾"ô ÷ʨ‰qݯ¾B™{éÿ£z¦×1RÖÖM^WËŒ&ydy†•|«ùFØ>kX[ÈÊe0ŒƉåÀ0[˜ã5Cc.³žÁýtJÖ\ÆÁqÜÇ€û„r0p!¬†Ex’ å„ÕlGÈ(ð‰÷ZdáºtT-ÌÁRB>pŽ÷fB>î¹çžÙ´iÓ|È`1nòÞx±ä¿îºëJûo,w¥ˆvlõ÷ %–œ |ªŠ³¬Ï`e^ÇC@U~Ã|Ï\²sëÔ,[JËć;…ø8ݸgˆ“0Ç5-.ÈuàV¼‹ @^MÏT,Ï[j€€/LǹX=ÒñHÕ÷EãÉ?·òÊ+gôë©?±/äÏf—æJ?øÁr0ÐऌàÅ:Ü¿°œxÇJÄ?Ѻà>¥T@Y5 G±ÒÇó#<¡,šN,½kÜ<Áë'L\ÄÆmFŠ:ÌÉ×óú^Že€9i‰a¦¼KîRD ªV"âôO<ñD¡îe ?u§ß†ïŸ;wnœýž`Œ3`ÞkX IBêÝ„p`цXm(À„÷9çæ9Æ:qrÂ1Ä9s"÷ø#öx¸ðÊJä‡b ,FQÇ^C]TåßÔ=¾/ùÈG ¼`Æí|ŠÅc¾éo–¤”®˜¹G:Ðô{¦ù³Ðo*ÌH}‹9šþR7´‡Ö#Aùæ²°g €‚‹}â±öPžqd£– ßB¾Mð¦×ñªõkê˜Z§ÕÌÅCƒçD/ʈüYƒ Ôò™sñ¼“+­áNo·¦aHÿaT¶9jj\÷£¯À^ûÿ(†žibŒ”õ¥&¯£ ©IþX^Æaæ€æÃÜ:V6ã€qÀ8`0L<†0gÏ‚ÀŽÐ8îcÓ¨@„·!Ã×÷r„ÇU&¨NZð\º‡4Š€¹xœóqßC>pŽA‰x™óX\ˆE!÷ÅJ¼bæîè•È"Ãôä…›ü:tõÕWÚƒgÛà±rãq%ÌÇ eS‚X€Uâî¦þ°T7½±[!`[a%׎˜¸B0ˆ<Å¥yËcÎÜ ÿ4þDKâ×/`5¥éÑ`aÂ,û‹ž»í¶Ûò¬±ÎÖ¼Ð6+ëº|@Ðæyæ™gô²?Ï]ÜÄ{«.,âC0]ŠÛûü}¼7H#ø ã #  .x ²`-Zòw˜‡1(Êʧu‰Û·*žqøá"ߺeæ¹2tѶã(®ûË’Úõ âÀ8æËÌ%q?¤/2~Ñ$V3–º:‰{Ýì±Çó­?ÇXŽ à&ìãÂ!NRøUt˜ž9©ŠRߊ2e(_†ÂüËNÞ‰–¬¤gC;2^Ðò. ‡QÈ¥çªz4q SX7ÎQ‹ >°på>õSo'ú,Ê\©¶¤¯¨¢ÞJb_¹ò–¸ˆoYøòÞ‹.º¨PFËâZ)Ϊ¥O¦ÊS·ouú‰APø‚fª¸öÎî¼óN šE7k‘X“@=ÕöMð¦×ñÚÂä/¤ÆŠ‹ 'ùw 'ø˜’º ÷@S˜kñˆ¯ãPû(Þ#Ä]šO‚‚yrOÂÝdxo‰×šÇ&Çu?ú eìun•°3~ž¾á†Z,ôsââÌq<$áÁ„¨)ŒMæ…*bc©Š¨´£„÷)$g®D›\ÛŒ#ó £Œ]þh;¥&ƈæÕÏã8 šúÉ/ËÛ80L0À|˜ZÃÊb0ŒÆáãÀ0æÈêýà`'4Žû˜“N:©Àâf³Ç…ŽÈ(0î©" L-£`Sˆ;`´×)IèH‰[ñìCɈ¶ƒ‡É&#Ò‡z¨Ullª}ÖÛ3fÌÈöÚk/opâD¤ã7²œC“°*…6%„{,¼³ìòk}¿%¤bYr9›¦åˆ"ø’æcв)AlË%´u°š¦“‡€y¬u”²O±MóÒÁƒu]L)À<%0ŸPÑYžÆaä€æÃØ*V&ã€qÀ8`0 †0—8×ù~˜}1{äNh÷1(×cCèZ¼ b Q&ï„WuÒB#Ï -OÌ‘qU„‡,«Q`Ÿ?~RnÑ `Nß%”$² £ _ ž†5·Ä¼¯*bå=p!ò Pc møÁ+ @=+a}y/'nÆØ ²IB…*&Wå>zlÇ[}0_ŸÑcìZÓꑲiZŽÁ¤ð2M?ÊGÌG¹õ^/{J[0çq,Àèä!`΀ºÚ)§vZá96ÚöBê0'¦,®Hµ<ûï¿¿·VÆb¹îßË/¿ì‹€Þ Áz²IBˇ˜|xp÷ ˜Çv/ÌêÇ!uFèM¬¬Ðbk͸ì<ß/À6NlµŸÕÌñœ{P`|¢Q® ˆ(5„Ë©:6=®›î+Zæ&ûÜ?‡1ôLÓcDùØã8 šúÁ'ËÓ80Œ0À|[ÅÊd0ŒÆááÀ°æ(~«w/ÝKwjI=Žûø‚Kp<áb@Þ2⽡%^'«ðçž{.7 ©’[t ˜ª’p¹¡1‡ö="ÿC.S†O´ã›ÙÒ„ô¥/})—ïð.0*€qde1q ïиc×rqÄ[òã?@ïË.»,Î*ù%†0_οño$ÓêE0¾ðð:B#`>­šÄÖÌqA`÷ìY( e „Ú+UìJÅ?ˆãz3àÃÁÅy•…ù³¢]¦?âˆ#ªŠPyI7Ì‹˜ªMàü#(D¤ÑFÂÊà(|g`ŽFÎí·ßÞWWŸÅêŒJìÎ#,§@ÏN4`NÛüã/ð·È)7ÑXÈ)?–Zj©¶Âþ7v>LÀ<5‡….qÊ8ÝT‡0ÿaÌ› uÖ¯ßç_ÿú×ó9Eç<{ç W‹S,Mù>2W2CÓë¥&¥yóæåñ²ˆ S“aFȻɾÕéw$AÑÊ­¢©S§xwÕUW’7Í›nÇk¡P üH­ÓªBç |àûŒ;õTS0§¸¸`g¨ý“#+ŽlYµ£¦ÇuÓ}EËßdÿ…Ð3Måc?Žã(hêŸ,OãÀ0rÀóal+“qÀ8`0†‡à ˜‡ñËÙ¿øâ‹1Îö1±«21že iÂÂ&—²8ÂûÄb _%·è0§|âŸÈå$l»í¶Þ#®Ð1ªQ£MŒ0lÄe;²ÀNH þüCÚtÓMówð Œ;ËldöìÙ…gxNqºèMß­C(MWø‡Kú*B¢òlÊ]~U£rÏóQi©Šr¦±us²å#GŒQˆI tåIç5b|ÂÄ¿{ï½·0ÐxVãfjò”ðº 0? q·çØÔ+a9M ÜPðA&®%ñc™„™ØÓÃɧ 0§|àáôéÓ} àð9ÎÑ~Ze•U¼;’T¹;:Èc¢sÊ@ŒøPûØ#Ä?HXuªå æŽÎ MVÀ¼jÓVj2„ƒæ9,€y“¡.´nƒ8bÎ=:Ϫ».\°ë<ZšŸ]¯ëWN ´o°Áþ>±–RV¼jå˳½†OMö­N¿#‚ ?[ùv饗šºiÞtºæ(¦ÁÝ®ÓèSh@ãz«Àœ¢N î߬SØ°Ö¡¦ÇuÓ}EëÐdÿï0½•yÒi:ôLÓcDùØ£ šúÁUËÓ80`>>Û[ŒÆã€qÀ80ªVÀûì ohwñÑ<á„ 1ãµþvœx`^¿ ˜{º á oÀ¼ß¡.´®ý8²PŸ6mZË"wQÌÅ„Ã`>Bë3 /ò»ßý®eÁÊ÷„…"Ê=›éÐCm)v“aFZ2ýB/}«ÓïH§ hÌï0ïo:]s”ñ´×뽬ӈ+†òE§€9Ï|ðÁ-ý[BªêÔqÝd_©*{/ý¿À|"BÏôcŒTñ²×{&hꕃö¼q`â8`€ùÄñÞÞl0ŒÆQàÀ°æ?ùÉO {`d5¡AVÞÚ>¦—ªÓ üOX]øŽá[Œ…9à9NApb}·¨5-2;òoG¯¼òJ:¯‘È'BüFŸGòðÃg¸OW¼,ŠPÆÈÛ^‘ÝÌS§Ty@ñÊQ‡¶Ûn»BŸFF Á#UÐ<Ï8ãŒ:YzƒM}FuÀo5fÔgp)?Žd€ù´j/‚ØTõwÛm·Â@ÄEE¤žáÚõ×__xŽ8 1u*¼fòZd‘Eò|Ïo¸á†8ÛÒß?þñ3&, GBP–Á%s]B»IÝë2I†ño‰W«1$ÂüêæÔñ;ßùN!†V‰LЀÃX¯ëD¤ÇØ­ïìèà™aÌ)Zg×\sM¡ž|`˜ˆ±¨ÂU;iøÈ ' 0oß.Ì ½†pз06tNà/Æ4Sߊ*íÎ:1ÌûêBËÜïcÊZ·âX…j¬r\SÇ„BOÈ{ΉWN tÎQða£Ó³ †‰ón¢ouúiío:]sÄÓVé¬ãºÉ¾’bDý¿€y“¡gú1FR¼lêš ššâ¤åc< 0<ÏíÆã€qÀ8`% +`þØcd5ÈfRÀh¯mSÅz÷N?ýto¼À xC8d"U@­“„!CWõ÷ö·¿=og€í0-˜‰zRÖwb¬AþK.¹dVÔŽ¥ÜS~d|ða(yß}÷•>ŠÅº*ÖcMƒþà¡#:„…{øJÊÏÀ>üðÃëd™aMæÉ9unGË,³Lá9ÌÛqÌîOR‚Xb=tKÄb   q4ÛVÂásX6ÅÔðzå•W.äûéOº2î¹¾ó÷¿ÿ}†`P @ŠµyÐʉÝÆëóáñç?ÿ¹·&?ꨣüe&„0nïIi¬ýö·¿-”=å’a*VãL¬1½úê«þ:–ì!oqS t`¡ÞŽ† 0l¢Ž¸E¹ú꫽¬Ë/¹ä’ìÎ;ïô UÚhíêj÷ûÏÌ«yŒ¶^S!xÓ0æýuQÍÅfﲇó+ß<âKsó‡z¨å¥xTá^øŠS¸kâc ߘb~õf$Ì»©¾GXäWQ“ h?xÓÍš£ª¾ÝÞK­Ó:ÌÙ¸ÀŸNiÞ¼y-Ç觞zjeVq[0×ôJMö•¸,Mõÿ~攵©Ð3q»45Äülê· ššâ¤åc< 0<ÏíÆã€qÀ8`% +`ŽŒ?”Óp®˜@]þÚ>¦.§ÒéæÏŸŸ½÷½ïõÊûX<×áÿzë­—·`x»?!ÂvÓnß}÷Ý…ÂÈ“~=ö¨t >¦ƒç[ Iy z¥•VÊfÎœé-´Ál)^P°œràciÓŒ3 eNaDñ3üNõGåé¾ð…BžuÃ*ŸsÎ9…ç00þTY”Êû: Sù û5³0öªQ>¬µ£êqÕUW­ñd:ÉSO=U°ê&ÏÍ7ß<8¸ºÅ[äå`“ ÈS7Âk&3­G¬þN>ùä$@­ï,€¥Gydžö°Ã+äà±óÎ;g/¿ü²>Úr|æ™g² 7ÜÐOô:áÆnN©{Šb1š81aMN½pï‘"ܘ ÁZÚc}ôÄ+ ùߎb7ú¸}-£~ ’™äwÙeÿ1Üqǽ[êŒ"îÚëć.+³], 0/çw?B8 `Îâ0ŽY@öꢜƒý»Ã7 œ;ÃóüãÉ9ˆy‰…r˜6Áö1ÿËÁï~÷»>¤2°›:nÌy2ÌCÙE·çßÿþ÷Ã&ÍãŠ_qÅ…ëí~ £¾PV>ƒ<ƒNþ8go®e>}zÒS3Fš†cÝ°{X†Ï½õ­oÍ A³fÍ*Ü[{íµÛUÉß?è ƒ ÏaýÞŽðPR¦”·åvùŒÂ}ÌG¡•Ú”‘‰?8œ×K˲eÐ!ìóD;ag*/´ÐBù3;ì°CRˇ+Ì—óvîÞ±‚Ž]Šâ¢ûøãOºçƵÀ+ÚEJ¸cW¢±5!ï µià,ÖãLôhé¨ÅàN;íT¨–ê€ô!!¤;úè£ éÐ؉IsÜh Mà8–©Ê;´–bzä‘Gòû¤£þä­„`øè!a¹­yrÔ8a=WËIMËø2 c‰^ Réq5ËdO:Üú. 0O·]“!Â70¿éxä8.Ù› uÖmç±²QÈÓ“N:©´(?aZ='†nÀRÄw!T~BÙ Û0#äßtßšHÀ¼iÞÀŸq̱ÇcNJk™z³–Á[ ýk…Vð<ÖqÚG9nºé¦IežïǸî`Þtÿ7Áð¨j£®Ö”§íâ}¡Økè™~ŒÚ»_4 ‚&æ4<† AS7å‹ó°ßÆqå€æãÚ²V/ã€qÀ8`04ÃaÌ‘Ÿ/¼ðÂ…½ï£>ÚQ¥»Ù'4 ˜â>kcö^XXwÜqØíHÃDdï½÷ÞµÿtÎÌ&~6öЇ÷bä#*OP~° õ±æŽ•1ÂrPoÂÿò—¿LV£…0=yÕñzLßð¹ÐØ™EhÄ„¸ò4Yˆ×/bæIèÐv~>Ãy6n—ï0Þ7À|[¥Ã2Ýxã-°4p;É–[Ïئ,±ÿüç?{kn4Xä=ùä“É×ñ¼¦Óc<‰Å"ø€×ôzøÌÆM:Z: n\làŠœ‡™pCKl&cŽ9¦%/&W&OÈĺÀ˜š™ðC…@^-GÒàZã‰'žðV,¿L’ûa:ÞsÇwxþhütÌYP(£­¶Ú*Ïkß}÷mIö /ä÷y'ï7¿ùMŸŽI «øuÖY§ ÇMhX>x¦ZJá àa¨Á3Ï=LÇ9E,˜§¦ˆ>Šc-¡PFøÊW¾âÛ "àüóÏ÷®ÙÑêB(]¦Xz‡] 0OóºÉá†0§žeSÀœ4‹/¾¸Ÿ`ã‰--uï@7e½È„‡–Qø.@ m¶ÙÆ»Áª+yÌpºå–[ÒÚ§ð¸Tá^˜÷ᇞçò>N‹à"&óØ{¿çÒá®ciêBý£pyB|ÎcŽNìïaÌcÏôçK/½´#¦uÀ5Â!,,‹“pLþô§? o·œ§ðUš‡x`!”“RÔT¨ Í›…23ë¡^=ô^¿Ž(鄼ä—P:_¦Þ ïX¨ÆÏ•¹c×<š 3Òtߊ­íÛy«‰APæí*B)-ä×%—\RHÞ$oȸ›ñÚþGža½9g}Õ)±Aéo,`øK/½Ô’ë%Ý„¡¸§žfX†k:ÊÀ·µÌ…VÓãºé¾BÅ›îÿýÌ› =Óôýèóä;gÎœ–~[¾*jj¬ðŽ³Î:ˇ#`=žÒ|ï¦|Ue·{Æqâ€æãÔšVã€qÀ8`04ÏaÌO8á„Â>#¬N¨›}Â(ìc' CHÉ:áOœl œL#Ä:X²dŽ€µvJX²«ŒÜ¥!/%Üm¯„|L% ¼Eb fƒüRãŠW½#–³`ØØŽá«uåxùå—‰eÝV!nƒ2A•ìSóB)",xÓ¸’æ#Ú²XS#¨_mµÕZbSjçEpMì@Q&ûN‰É Ð@\7ÍÔ›µæškz€™¶ÝvÛy­ €Ût5”jkùôàM¬J ¬…RD hÞºšÐ<Â#a,«ùX•“ñb°6̇:}þóŸ÷nÙ㉰ð¹¬,(0 òž àÄ|Pð)̹@Œ59BñÙ³gû VûÜ#:<Â-gŠÎ8ã ÿ ëPrR¬%q3¯áyl ÎsÄU¦N¯±ÙcqÖW=tTå»F"êPEM†iºouÚƒº†}ÖŽÆqç€îýËöœã^«ŸqÀ8`0ŒÕfÀ<övÙe—êÊDw»Ù' û>{çwöžgiÛªKJ"s ?äúXöc„%vÙŸ‚ÍO"Ód¯Ö\¿SÀ¼´=Ü`ÙéZÌjtÊ^ùLUÈŒOCÅ~Α톄U;‡º÷fÿœ’ñè3»ï¾{žcPŒDëž õù=®ôwTL*i4bí(wï½÷:œmK.ßM:ÕÉÄØ6m*ÁsÏ=çDèD{ÆI¼'î@ X'`«K`' ™“Éщë 'D'àl!™<œUN4mJË+«A»€Ä °Zx^ÐUE€ën¹å'Š“˜N&Ÿ§€ÌŽ?±ðöeÐÖɤ£&ò±pb)îäCêó%o±ìvf9šú|DáÀÉdä(_L¼[¬©ÝM7Ýäž}öYG=Äu¢Uå6Þxc'Šþ·€Îîˆ#Žp¢1åĪ@Ú Xí¶Øb ' “NÜòË/ïÜöe+x'@º¹¯¼áº ÉóY€þ¸8þ÷+¯¼âèª;qìDØáëCy6ß|s_n»í6'.ã€þN„íÉ|DÃË·‡€ìN,p}ÚTBòá½Á¤“¢ðȉÀ>•Ô—E¬Ãä…ûâ¥À·9í .Mþ¾ÖzËϲÈr¢Ø”_ûö·¿íç•üBtÂœÉ|ï#ÿ åÄ8¿%› ' rþ[Oø1ˆ’^òGÊ/Ê6~Žà½Ì[ÌK²@öó!ssè?øÁü9é,ºü¼ÈEæ¾/óçÏo;§ç™tq"‹I?w˦Ï? o™³™£«ˆïš,ÔßIˆïáƒ>èçò²çh³éÓ§û¹5Lûȋ¹žo ß#¾3b;±v¢hå$¯Ûzë­óïlÓ}‹þ ÊPy±DÀϱ´=ß ñìáDt7ß|³oOѤu|'•øV2w—}ÅU”oM?kÖ,'ÊkúÓ÷ç¦xC¦Ž×~õ?ææŸX/Éf)¹¾Ó‰¿N‘Ð&Nb–;Ö.|ƒ!‰&½O>N6œ~¬2†Ã5ýœõÈ©§žš?F[1~8à€ü'MŽkòkº¯g“ýŸ5¦xâqâù†¬=‰¢¦[c5ôg~dm&Š€~]«iÖZ11G|èCr¬Ï Ö¹Ìy¢,êÄuœÿ07²>Ô#ë*ñîà˜‡bjrþ ï~õyòÞgŸ}œ(¥qšë_¾we”+ÌI̬…«^³_·v~žbüCôoú}LÝ”/ÎÃ~Æ•ÌG|3ØߦöÁãZo«—qÀ8`0Œõ8ðãÿ؉·c/©÷Ô`RYP6öÛ{ov {㪒t³Oö}ŒÄwâíËË™¨; òF0ŠnIÜ »½öÚË㬑é‹Òrev컑u!dÿ†ŒyS§„ìM¬Æýcì‘CÁ§SN9ÅË2´¼nØóþÅtå•W:ñöì×äÈ‘_‹×¹B2d7bp™ËtXÇ‹ëx'FŽ…tü`Ü"›%sŒ†ò€µ#°+äÎIyl mÉómU„@¯ë“G;ÁU^_Ò–3±!, AÀ'ApØH“!@MªSN&TqÅí'Cx@þùdįKÔ…I‚<ùcâbÐS@$Ϋ~ð@ ÍÅCîŠA7ô!„ååcBѼ)?€‚Q”ƒz˜ó,"ii¿Ôä—úðá!ò£.|°Cä¯cülø!;óáå–sÊG}¹i—*B0‚s€ë‰€ÞðŒIš~…€†?úö7ýÍGåê 0wîܪ×Ú½q`XsÆ’¸ÉñÀ}&$‰âùÀ‰å«gÃ{ñ9}Q¼86¤ÍH/gJ‘hë¹ 6Ø Iø0fN`Ü0f†ö‡s;‹@Æ €¬‚²ÌSrÂׇùC fR éN?ýt¯¼¤é92æÊba(߀¢pî7Ï^qJ\Á‡Yøs¾3fÌp€F1ºR_êÊ\ÉXF)‰`kè¡h¤ µæÃœ€b’¸H×K}9Šõ®›9s¦ÏÅ­yóæÊVöRøG¿€Ž<òHÇF¤±°¯,þÛ¦…|Sù– ÐÄ|Ïè§vš†s¥¦ûß@{ÝXò6—´ ß0À{·è|ómY˜‡Ä=ÑXmá€)€"ãQI4½2DøÝnŠ7݌צûãŽúì¢ì›çW œ²Žb|°ÁçûÈß;q™æ×áü%Öâ~Þ"OÚå6±ÞõiZpÿío{øJ.šï^q†÷(1*ÒïoJMkúU?úJ“ýý3T$”Ð3îQÒõœòÅ6ŸaZñ°ãÇk¢h3pÖ3J Œ“–¼™Ã#ãŸ1Áø ßxNojŒPž¦û±W‡0®½øâ‹ÛŽ Ò"_ûQCñøëAþX–LÚ± ØFÆã€q`à…ˆW‚ Ó¼«x™Ô å§wÍ"ÂPç^Ï™LÎÞÍ,1;döî[ Ù ã€,X|›àâu÷Äm½‚ úþÉ¢#›2eJ&v>¬Ä]wÝÕRtúj/a%o$„nzdäë$ •¼ZÆ‘ó™, 2Yhåa)Õ@ÜÛØÝ0Ï]´3Q\ñõÆ­;1‡à™8…wÈBÈ»Xâ~*îq¯¡.(!´>áQ,i[Ú¥é ¢‡é€¾vö¸"ƒ7ô%ñÂRë9úTaFšê[a¡ë„öðÞ‡¥ª–ö"~¶(2e'L6P>\‡† ÛUÀ¯L€°ŒcJ½ò¦—ñÚdÿ#táp‡%h Ÿàƒäaid£èñ0®¼ö¿ù6 à ýÂXç{áòL¼ø-Ê[Ƶ(odôÄûßôWM«G\¸‹'š,îû½Žë~ö•&ú?.éE2R¡gz#aŸh²Ï3Öùžˆâç's¢ö¯ðˆ9¾1|ŸEÑ#«3Vø‰â§ÿÁxåKÿÇ$ƒÒ1F:ÖP·å ùeçÆɾOŒ[öbFÆã€qÀ8`0b ³KvÊŠì8 *Þã*ä¿»Ý'ŒÒ>9^¸'#œ`»°Ž9ƒ'ìåt½æÛɹ€·‰œë]—ìõJšN%Þv3do*SƒÔL¼&û°”„1#.²jø)†™^¾#J éÌ^¿Škvñ"àÃï²'¼®x6õá~ ÷ù‹òH&½ÅKHƺ„üR÷÷V8Ò§dqï½/ªƒ±X®T´_ÕºŸŒzáM/ãµÉþë†Î)0¯Æ,Âq½a¹VpØð—ßXÓJôOQ6óÞYôZxä94› áR/ãºß}¥×þÏÜwà 7<{„u绀æ;¼¦Ð3½Œ‘°~Möy<¤àé€9‘òµ#Ö|̹X‡÷k¬àbÏ P·å‹ÇC»zÙ}ãÀ8p€oc™o*ß#ã€qÀ8`0Œ!†ÝÂœ²âý+hö&¸½Æ92­˜ºÝ'ŒÒ>Ï·G}´—×±¿eÃ>©ÌSfÌ£ø7|-“ñÄiË~ ˆï#wCÈC°˜†"5Âaà°$Çô)¼ ³G¦CÈF<Þ0”Û•ÕŒ™,rF¼â5ÏxÈwñd‡‡C¼ àíYHj<¤ò&¤¨z—ĺ¹m'N*Ïa¾f€ù0·Ž•Í80Æ`ÒœƒˆÉ °Y—˜ì‰¥ËÇwî€wFÏaÌq![šNˆÉ‚ .Xx„Åuèš¼p3úÈZ¶ˆé5„î¹ÕýMôÚ–Ÿ,zÄbÔ/~^xáï>§%QpPWë¸ÿn†Ç=¡a%‚lü)®zXä±øãaëÿgïLànÎü_þa“˜Ä—„0Ö3¶HH\"‹Xckb'—X®Ø¹vb bß ‚k, 2Œ5ÁEf02‚n†k‹uÆdL–™þ×·¤Ž:uªÏé³wŸó«Ïç}»Ï9ÕÕUߪ®®zž§ž".lZmuÁ³rŽrrÝ[láÜìN›6ÍØ•ºñ­zþ=ƒþÕW_½­´™,¢°ì$0bPKýÚ³n2Ǥ…¿¢ÛŒtÛ¶âÂRhåÔ]¸µ{cÐÐ,0ÀG±ëÛB‘¸qœNØtó¼ö²ýµ»uN\öfŸ™èø-ZòúŒg˜ … êÓï뜗>ýý`:}®ÑVºiÿ”³UŸ‡ ¿EKºõL'ÏHX·½lóEßáýÙ.ˆ¾“¶ÙÀ»‡~”ÐiþR.ïú‘W¥)e" …y™jCyò¨‚Âœ­CÙ£ùÚk¯uò\’‡[5yªÎª4A¾†\ù ò”¥(Î; ¤UÄHºYúȘ:UºâÞ+ì‘} ÿ¬b  Q'ÈuøC6ˆ ‡íõ "_FVÊuZ•“mËà +ày 2=ÿ‡œ(Üê±Uz,*bËN˜[oqæ–[nq‹^Z]Wåߥ0¯rí)ï"PQ¬X@é.¼¤Y‹â¼ÕK€=ãÏ>ûl·JŽŽš·^ZQ#“í²)ÌG옃öÛa/ߧžzª­ݘ"S±{H@í¯‡0Ç4)„xNÀžN¦Nê¼Q„ãÖÄÃâ›sþˆËÄO앾Æk8Oýƨ6ßoÂJ_ªC@ óêÔ•r*" " à P…9\X…¼Ùf›9™Ò†nh®¿þúŽ•´Ãà¬{Žä„^zxB)o·8k©oI‘&?»ï¾»[¬ˆq~YØÊ4R×Uý;)Ì«^ƒÊ¿TîJ+­Ts·LG‹ò›UçvϳÔRK¹U¾kXu„àK&V™¢8Ã…è /ì:ì”u`‘ŒD–¥0‰j,E!°`ÜqÇÝSɹVúÖ·¾UŠ|)ãA@ío<ê¹ß¥¬ÒÖ3jóýn J_ªE@ ójÕ—r+" " ƒ&P…9« qyÍvž*Ÿp f¯½ö4.ÝO*Ià²Ë.3û[ÍÄG¸óNÝøW €æUª-åUFˆû$3HAîÂV‹ãÑXT±ÒŠ?öÆ•,笸Úe—]œ‚×+ å …y9ê¡ê¹xä‘Gj{+±/{ã:HAA@ío”ÇãUÙzFm~<Ú£J)í¼ZŠ+" " ãG * sjÕ3Ož<ÙÌ?ÿün‹Ïm·Ývü*M%6Ü|óÍî™™1c†óœÇ>æ—k¯½¶Yo½õÜþÂñެͮÕoƒ! …ù`8ò]؃ˆçü…^p5LbدGAA@ío”ÇãUÙzFm~<Ú£J)í¼]bŠ/" " ãE J sj†ÅZ_|±a•ìB -d8à³ÓN;¼kéñj•*m¯\wÝuæè£6Ó§Ow«ÊQ–w³ç}¯ò5¨t¤0iÝGD À{ï½çö“¡ÆõòË/¿lÞxã ƒ2}‹Ym>aÂ÷·ÜrË9Åʳ9昣!-}1|R˜¿ªžöÖ9ðÀÍĉa̼óÎ[õ")ÿ" öW¡Ê*yV«²õŒÚ|É’²'C" …ùÀë¶" " "PUS˜ƒõ­·Þ2S§N5Gu”ójºýöÛ›C9D{šW¤Í)›ƒ!pÆg˜sÏ=×¹a?ôÐCÍFmäô2ƒ¹{9î"…y9êA¹±&€›uÜ­ãvW9|Æ%ûœsÎéþæšk.3÷ÜsËò¯ä­D ó’WPE²7sæL³À ˜Ùf›­"9V6G‰€Úß(ÕæpËR•­gÔæ‡ÛNtw(#)ÌËX+Ê“ˆ€ˆ€”‡@æÐ{÷ÝwÍ<༲xëÑG5ùÈGÊV9!Ȳ̬²Ê*ΠäI“ÜV¸ã¸E¦æCl„ºµˆ€Œ)ÌG©6Unhë™nèéZaÂ|˜ôuo(?ª*Ì!Ë– Ï<óŒyå•WÌšk®ifuÖòWE`@î¹ç·ˆi©¥–2úЇt×rÝF órÕ‡r#" •% …ye«Nèm=Ó¨JRD ï¤0ï;bÝ@D@D@*M Ê óJƒWæE@úN@ ó¾#Ö D@D`<Ha>õ¬RŠ€ˆ€´G@[Ï´ÇK±E@†K@ óáò×ÝE@D@D ì¤0/{ )" ¼SrºND@D Ž€æu8ôAD@D@D@D@*G@ óÊU™2," " % …ù@qëf" $ …ùaëV" "0ʤ0åÚUÙD@D@D@D@Æ€æãPË*£ˆ€ˆ€tN@ óÎÙéJr¼Üõ£Ü‰€ˆ@eHa^™ªRFE@D@D@D@D I@ ó$})" " "ðgR˜«)ˆ€Œ*)ÌGµfU.0)Ì \·¼Ç@•œˆ€ˆ€Œ)ÌG¬BU)Ìk(t"" "Ð óÏ?ß¼òÊ+fÒ¤If¾ùæë&)]+" " " " "0Ç{¬ùÓŸþd¦L™bf™e–!ä@·(3dÈZh!³Ë.»”9«Ê›ˆ€´E@ ó¶p)²ˆ€ˆ@·ÞzË ×>þñ›Yg5/š¾()×_ÝdYfæŸþ’æPÙ& ëÎ6ÛlæcûØ0³¢{‹€ˆ@O HaÞSœJLD@D@D@D@D@D@D@D@D@D@D@D@D@D *¤0¯JM)Ÿ" " " " " " " " " " " " " " =% …yOq*1ª¼*5¥|Š€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ô”€æ=Å©ÄD@D@D@D@D@D@D@D@D@D@D@D@D@D@ªB@ óªÔ”ò)" " " " " " " " " " " " " "ÐSR˜÷§ñ&ðꫯš?üáã A¥ÙgŸÝ,°À]ÝK ó®ðébÀŽ;îhž{î¹ð+‹€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@_,¹ä’æ /ì*m)̻§‹E@D@Bgu–a•¹‚ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ô›À„ ̤I“ººæ]áÓÅ" " !7ÞxÃüéO ¿Ò¹ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ô…Àl³Ífæ™gž®Ò–¼+|ºXD@D@D@D@D@D@D@D@D@D@D@D@D@D ª¤0¯jÍ)ß" " " " " " " " " " " " " " ]¼+|ºXD@D@D@D@D@D@D@D@D@D@D@D@D@D ª¤0¯jÍ)ß" " " " " " " " " " " " " " ]¼+|ºXD@D@D@D@D@D@D@D@D@D@D@D@D@D ª¤0¯jÍ)ß" " " " " " " " " " " " " " ]¼+|ºXD@D@D@D@D@D@D@D@D@D@D@D@D@D ª¤0¯jÍ)ß" " " " " " " " " " " " " " ]¼+|ºXD@D@D@D@D@D@D@D@D@D@D@D@D@D ª¤0¯jÍ)ß" " " " " " " " " " " " " " ]¼+|ºXD@D@D@D@D@D@D@D@D@D@D@D@D@D ª¤0¯jÍ)ß" " " " " " " " " " " " " " ]¼+|ºXD@DÀ8ùä“ÍK/½d<ð@³à‚ ú¯uuêŠ}@IDAT¨ý÷ßßüéO2§Ÿ~º™e–Y*’keSD@D@D`PfÎœiN9å³È"‹˜}÷ÝwP·Õ}D@D ï¤0ï;bÝ@D@ƃÀ¿øEóä“Oš‡zÈ,³Ì2ãQh•RD@D@D@D@FˆÀ ,`~ÿûß›7ß|Ó|èC¡’©(" " " ½ ðÄO˜‰'š•VZÉÜu×]½HRiˆ€ˆ@)Ha^ŠjP&D@D úVXaóøã;¥ùrË-Wý©" " " " "0f>üá;…9«Ì¥0³ÊWqE@D@D ù—qÊòÏ~ö³æá‡.p…¢ˆ€ˆ@5Ha^zR.E@D ô¤0/})ƒ" " " " "Д€æMñèG{R˜}YR˜lÕª`" "0XeV˜¿ýöÛnõÿùŸÿ1sÏ=·ùøÇ?næ™gž:@¬¢yðÁÍG>òCYD@D@D@D@D`ÜHa>n5®òŠ€ˆ€ˆ@{¤0o—b‹€T‡€æÕ©+åTD@JM L ó?üáæÿñÝ^J/½ô’yçwÌï~÷;ƒRü/þâ/ ‚À…^ج¸âŠÎÔÊ+¯ìâyä‘æoþæoÌå—_^c}çwš_üâµÏñÉsÌa&Mšdf›m¶ø'}±#ðÿ÷îYkVpž™YgµY”B¿eYfþë¿þ«iÜÿ÷ÿþŸ™k®¹šÆÉûñ–[n1ÿöoÿf>ùÉOšm·Ý6/ZÏ¿ÿ÷ÿwó“ŸüÄì¾ûî¹Â}íµ×Ì/ùKó«_ýʼòÊ+†Ïo¼ñ†9ñÄÍÒK/Ýóü3AÊöÀ˜ŸÿüçÎjÊ”)ÃÌN¥ï}ÕUW™EYÄ|á _¨t9”yî HažÏ÷Îc=fž~úiç¶þ¯þê¯ÌüóÏoØŽê¯ÿú¯Í,³Ìâ.~öÙgÍ 7ÜàÆŒ#Â0Jc%æI/¾ø¢Ùa‡jeËZäü÷¿ÿ½aîV40ç¢ ÿýßÿmþ÷ÿ·hô¶âõjL›wÓQj+”±í%U/žÍ*·•<.©ïŸ{î9óÌ3Ϙ7ß|Ó°°à½÷Þ3ýèGÝ¢ú3ä:ôm­‹þøÇ?¶ŠfÂùÏ:Ï|‘^Æïå°Ÿm2Ìó(žKa^ýZ¥ßU¹A7²œéÓ§úÉ—_~ÙÉQXT…ü˜¿å—_¾#Mõ[Ëx•@ óñªo•VD@úF , s”Ûßÿþ÷Ý~ê3gÎtÊ» &˜Å_Ü0¹bðÃÀgöÙg7óÍ7Ÿûcbˆ°åØç>÷9óÐCÕ8üñæ?øAís|ÂÞŽ 2Y¹® ãNàüóÏwâf¶ß~ûž( Q’}ôÑÍnexö/»ì²¦qR?>ùä“fë­·v‚$ú‡Ç<­§ßÑ?M:ÕœwÞyæ·¿ýmM \ä&¬î¹çsë­·š§žzʼõÖ[N†Pj‰%–p‚¯<Ðñ(’^Yã 8~â‰' úz„}¯¾úª3 `ÿ< ¥Ú'@Û[sÍ5Ê[la¾óï” " ãI@ óÆzÇø–1ïŒÐP2¡„e>A‰÷ªE]Ô¬¶ÚjfÙe—5W\q…ùéOj.½ôRóµ¯}­.ÁQ+1öøÒ—¾ä ó~ô£™UVY¥®œE?œ{î¹æÆo,Ý)ßh£°Zh!ǃç¿ýÛ¿u¿Å 1þÁÈ¡áØc5Œ?úF¥­À§Wí%fÝËg³Êm%æþÏÿüOsýõ×;CSä!p£NP^‡‹ èϘû úêW¿j¾üå/'a¸f«­¶2ÿñÿߪá3Ï)}!y c÷"!¼.ŒOÌ<­YÀHøÌ3Ïl¥om²éMGèG)Ì«Y™ã 7èT–ƒ|áÚk¯uò`úL]Á C½¿üË¿t 1è¿õ­o™ÕW_½š @¹.FÀ HD@D@D k÷w—Ù7Of']§Õiv€“YAUf…(./íÄ7»ï¾û2+(qV©”]yå•™n¸8ä9ü³ óºÛÛ$Ù…^˜Y…{]¼ðk]w͸|ø‡ø‡ì¸ãŽËì*ßyÐ÷H¡Fì&·Ýv[6yòäl³Í6ˬ 3ù̬´ÒJ™xt]r»ê;™>ϦÈdv…vvÖYgµ}Úóú믟ÙUb.}»â¢í4Ú½ÀNȲ#Ž8"³ÂÌ®Dˬ =³¬BÉÜu×]Ù–[n™Yaq¹gp@fðÙÃ?œÙUë™]R(½2G²B¹l5ÖÈ[l±ÌNZëêíµ×.sÖK7kˆÝ|óÍÙg>ó™lÁÌvÚi§ìõ×_/už•9þ°J`׿Z…HÿnR¡”g̘‘}ãßpý£ÿÛ­Ü\‚1 㾇›õÔ‘1'²«3ÝwVáÙPÒQ+Q(»z+³ƒ\9wÝu׆rýÂ!d{î¹g6qâÄÚØËsÎ;Ú•§Ž·5TÈìÊ~WV€1WˆÇ;Ìû¬7°Ü¹_Þ=Š|ÓM7-fGñF¥­Pø^µ—d¯ŸÍ*·•K|~÷Ýwg›nº©?[…¸{f­([rÉ%Ýœ‡gÇ*ƳOúÓî7æ@ûØÇÜ|ŠgÇ«ÆIf¼;ì°Ì*Ü5©ç…qå>ûì“Y£˜Úõ§vš{­Qsò:îýõ¯=;è ƒ2kD\».>ÇXaÎÅ º?üðºxá5ã¨0·+nråŸøDf]?70îõƒ¾_¯ó?.é¡øµž\›@èä©áób·EȺ0ZW§n2¦ëϸZ/B´NžM»Z¨ftCšýV˜Ó¿ì¶Ûn™õxáYÖ{f­™[6XrÈ!Êq˜’W„õßþö·³iÓ¦ev;Š¡qËDK#ÚT |s”¼»Êƒíý÷ߟ}þóŸwÆvÕPfWðt—¨®¨$)Ì?¨6úÆm¶Ù&óó”9¡äe.QÚwÜá ôP܆ï%Î1†‹Ã(Œ•(Ózë­W+ï¼óÎëŒóâ²ùÌ8Ã>»Z1Ûe—]jiz–0·ÞÃ2»ŠÝ)Á0Öe¬ã•{>ŠÀe–Y&Ûwß}ëÞ_v%­KŸúBièãû#u‹PÜ®roøCo·,qÆÓÖë˜SäyÃl®·+v‹±ã8£ÒVЫöâaöãÙ¬r[ñ\Â#†¦ôAÈiü\vû•¯|ŵuë­+³žò²_ÿú×smÆv §ìSŸúTí9Áù†•aÀØ9 JSë¨ß?W/ºè¢Ìzñˬç«Ú¥Œ-yÞyÞ¼aQx FHÿú¯ÿêÒ¶žšõªR‰€ˆÀÀ [a~öÙggÖ=zmƒ0ƒÉX³€Bͺž­]Ã)¥0' „4~2ÃI`³ûÊoL^×YgÚ*&Ký ƒ¾_?Ë2NiÛ}27~^øŒraG§ ©tùî‚ .è4Ù ñŠ‡~*Ìa´×^{9¥¼Ý+CYnݨ·Ì¿uÙží¸ãŽjÏU"¦~ó›ß´¼¾ÊXÑ‚AÁ1ÇS+»oSU.W«¼SçX¾÷3ðLbl‚ÂÚXã~æIi‹€ ž€æ0g…xèÑ.v_Ë eQPLÝ{ï½N!‹‚׿›wÞyç0ZÃyÇJ‚§±'!Ùݔڞ?¢¼ChÍøˆ•¥x@a¬ƒ š{.°Àu× „CñžgZ7ùuq¹ã'Ò'~üǘÅ,J}}(ò¦L™R›¡LT¨j[O?ÚK¿ŸÍ*·˜ãiÕÝäúg ùžÀ¨<"³ uã7®]Çõv«‰Ü•xdãïã¬ÌÌ ,`Øÿý®Áè%î_óÒà{îáïÇÊrƒEB?Úd‘ûŽR)Ì«Q›ã$7èD–Ãû°»áUƒïRá…^p«Ë}ŸƒžÂhÂ|4ëU¥¦Âœ !.¿üÀ…#E&[(ÕíÞ­µkóæ¬0ÓÏÇIaŽ° ·‰^˜ ‡~*Ì}¿?8#~C\˜†ÏŠ?ŸsÎ9;¶ÈE®|ðiúã<ÐÕ×^{-éV°_ sú'ܦ#Øeu„²­†>¸¼ø«®ºªÛz"or×*Í*þn÷«k[£¼Â>Æ]Ô{¿÷bµäÜsÏí”!&(ˆ€Œ?ÆËS¨Œ ¶ñã ŽÍƼ×ñº´É&›Ô®Áµp«P¥±’/ «¸C.œ³}†Ý®ÓÅ£L^@yÎÖYáêY®gìÆ Ö8°Ú5NŸ1T;Áî¿\sïÞL!ØNšEãV±­P¶~´—~?›Uo+¸>gËßÞQ|òÉÎX«öF_öÔSO5Ì‹¯`HÆŽáJoO¼5 ¬lÇõ»Ï¥>Þ&Š¶ßó׳…AÑÐ6YôÞ£O óò×ä8É :•å°`!\xÅvžÍ‘GYës˜/c̦0z¤0½:U‰D@D`(†©0Çtìú™}Xã=ìòÀ üòû_IažG)s'tRÃĶ_ s&냼_~ÉõK§ØûÉ 1â#«´: ¬ ÷À±…{°ú§Ý@[c¥7ý.©é?|~û¥0gq¿Bœ½‹¬ˆÀ8‡ýÕCw ¬¬ºÇ®Œ§ ãb#¦QV˜_zé¥Nè™÷~êu½c¸qðÁ»g€g¡d¯ó¢ôD@O@ ó÷™³’1€p,ò®fµåÒK/í®ÃcG«P•±’/«Õbo<°a[¬+®¸ÂGë舑FÈ›óV Q²³’?¾n­µÖjÈCJ!¿Új«5Äkõ…˜£¬d¨Z[M?ÚË žÍ*·ܧÇ+¾q?ÞîVUÈHæ™gžºg —é)/~(¿c¯Ìs00É (Úñf?»l«W4L´[qqýK,៞?²o]»ÕʬÂ@÷Ýwgá>¤ýP˜#hòûdÁ¡èD %f¸Š ?{õqãÞ.“²ÇûäQU˜ã"ݷǼ÷S?ꊕUÞp„gîùçŸïÇm”¦ˆ@ Haþ~¥<ýôÓ cÜø¶ ŒaÙ"…q £V¡*c%_Æñ˜ÎÁxO5XöéÅGŸ–?¶R˜s={Êûøþˆ7£xåžxüïþ؉œ°(¯32T­­À¦íeÏfUÛ s%žCß¾9²z²“½v1`Ùm·ÝÒÂCVP~{yJxïV[e1ÎÅØ&¼e?Û$´ /½ôRͨ‰•æEC?ÚdÑ{R<)ÌË]›ã$7èF–³ûî»×õ?Èš…n¸¡.>Þ8F€æ£W§*‘ˆ€ …À0æyû‹/µÔRÙå—_žÜÃ.†„+&j¬.M…X9NêR s,ß{éÊáÑ~”n)!å`¥÷'?ùɺÁ¡gÐk…y¿î‡¡—u×E¿8^‘ϤE~‹†÷Þ{¯”+Œ½`w—±ð†öêîv+]½Âøè£Îþþïÿ¾¡M¶«0öÙgk[:œp Ž»WP’Ç~(Ì>yá×"í7ÙóÏ?]yÙ£óí·ßnáÈÄûäQT˜³OZèrt s>{ï½·ko´UösSR˜¿_Ï(ÇýX×·Ùf›äX9nÌ Ø>öXiÇ­ÂXÉç™±é +¬à¸|éK_r{¶{6i;ÿôOÿä£wt Ó㼈œ£)%~,Èî•”yÞôéÓ )õ:‚sQ•Ú EèW{ijYÕ¶‚Ët?WòÏó0Úl'áñǯólEšŸøÄ'2 +ãàå)þ¾1HaL™˜ÃÆsDžeä;­Âyççú"úÙ¢FØýj“­ò:Š¿Ka^ÞZ'¹A·²¶= û,Æ6Íäpá6ôµï¾ûny‚rÖ1Y¸Ò6 芀ž;¡2Ö ¡Yn¹åºJ«Ý‹­ÍX7cÉˬâË|ùË_6;í´“Yyå•“qøÒºX4VYf–\rI³Ã;4ijûà»'aÃ÷|a…bÆ®Lue·.ÐŒ°;p2veYdc÷Þ3VÀfìJ‡äõ©/_~ùeC¹¬@ÀØýxŒU «0w÷±ûµ›/~ñ‹ÆN@S—b g.¹ä’äoþK®§¬v0hȳ]™a¬Ë4c#fVg–]vYcyæ{ßûž9çœs yJ«Tqeä7;a5vŸ]c]ܧ¢¶ü®—÷ƒ—µZ7vònf̘áê˜:ùô§?íÊh'çÉ6ÑK~Ó¦M3V›[î9æ˜ÃØýÝŒ ¸vC^‰o• ®íêccQÌæ›onì¾quéX7y®lV`g¬PÇØ=­]{³B×V©‹fve‰.ÊꫯîÚk³øüƳd÷w4V™i¾ùÍoší·ß¾.ëNÜ<òÈ#Æ •ë¾Ïû°á†šÿøÇÆ®X7vu±c*uÑáGÛ-hÿäëºë®3vŸQc]_«”6Ö­Ÿ±®]Van¬[Æ"ÉŠó/|á ®Ž¹Àºf7›nºiÓk÷»ß¹~ŒöäÏ xŽh—ÖM™yã7ܳNÿÆmÏ â\ÿÁ3æý ’ùµ£]éâ®ñ_ðÜSÆT°îçÀ7ü÷É´1+¤wñxö釭0ÏXE…{v–Yfc]E6¤“÷E»eÍK‡ï­ L×ýæ7¿qÏ}¬õ,—OÇz!0vE×ÞáCàæËÈgëI%÷½Ò‹ü?üðÆ~’À3wï½÷üýîn®" %@¿Ëû‘¾‡þz\}÷|óÍçÆcžc‚Ã?Üì³Ï>î=è¿O­Ö½ãyW[S*Šû®ìc¥0ãVo6Ø`7/aì+\®cÄ<àúë¯/këœ1q¬ÂÜÍ1ÃïâskðkSóþ왣úÀXƒ1K˜O1¦.ìŠr7N·ŸE¢÷ýôÓ]?&„<¹‡5ø¬}ÍsÉó>‡µÿ|‚,áÌ3Ϭûúk_ûš±ÊÿºïÂÌבg6Ï°ÝžªÐ\¶_m2ÌÛ¸œÓ¿Zý泟ý¬aΠPe‘ ‚F/d9vk³ë®»Ö²Ëøˆ#Žpr&d£a@ÂÜø¹çžs_Óß"ˉÇ-á5:¯(û’Q® s…9þö5œûÇ~Z«¬²JöÝï~7ÃJ:/X…pîjÍx5cx¿×_=;ÿüóÝêtöÆÊ™ßY•ÇêT« Í¶Þz댽½Z;èËì4cß=®ãzÒÃm3é±w1nrÙ?쨣ŽJ®l°ÎÌ*W›þY¸+ëž{î™±·…Xsóǽ&ÚýÀps†‹C¬ÈÃòÆçVXV»n²Ÿyæ™VÅÌý½W÷{ôÑG«D\ ãjýìSèÜsÏíVýÐ&pɯªï%?VA7« ö[ò y¬ëaM=cΩoVÏú•üÄ?ñÄkr\ûöæÛ õùío»é>u<Ö$ã¹åvsÈ­¤6~ð+aÈ?«­üžž¾|aT$<öØcµ½ñpÅj…nW˜ŸqÆ®]àúï¿øE-ý\an• µúµB¤Ì.Ôî›wbjõìÙYARÍë„»tØo±¶A¿Ä=é{¬ABf £\Ÿ÷Õ¯~5c¥ûÆoœYáyÝíY=ÛüøÏNJëâQ·qÿ™½ S!î“icV¶Ñ.¬ðÆåÓdVÑœ‘O+,Ì^yå•Trµï:-k-à„P´UòFCû‡žLÖ]w]÷³‚)÷ÝwŸ»†þÞ×7Gú.Ï…£5òȬP¤îò^æŸU‘ôï>q½ÕÝXD@F†€V˜¿_•¼[Ãñ€ï Ùžˆ9E«w.ã~«Äqã¼f£ìc¥0ïÖÀϽ¿ZÃ,÷bõªgãßUízû ï¦Åy‘æluÃ&¾–¹]º]5l,ݼ)LsçUj+péW{ijYŶBŸƒì ~gwößÿ†4ý¸;N—9e|úËfaÍ5×l¸Æ¶dÍöfE9ó(îuÖYg5K¾î·~µÉº›ŒÉ­0/gE[n0H*½åXƒöºù.} ò7»h¨N>†œ–y=2YÇŠ ²¸º× ` ª " " ]¦Âc(ªãÉYüÅ)B&}Ö"¶­2ÇÊ™0m&(·Ãïâs­\/£8Ûc=2”wþz¦ìŽ[%ödGùê£Ìì—EâÕW_á6ÒÇìidWÝ;LüŸÙë %.û¡óÇç7âð‡²ÖZ\¶Å6ŒÜ‹û¡,Çý[¨lbrŒ‹:kê”g¾ ‹.º¨s;*‹{ÉÉüÉ'ŸœëΞ|œzê©ùðyJ©Œ(p9I{ó{ §âòÂk¢­;ÇõT(XDgWÔÅéŇP°Gzv…CC9)»])Òòv^C½¢ˆ$t£0g‚ƒ»TØZËâ:·è¡€–½ ׄugWš7uSèï›*'ýî ™¸Ù•÷îÃP¢ÚUüÙ‘G™YÏ…Òö÷È;²=À”)S\€eçwήºê*×Ç°‡!|0FÁ`ã¸ãŽ«K׌\Ë®a[µ«OêâaœsÚi§e´Ë¸/Ç }*Ä}2‚;&ÍÖC£“ð¾ìQ+ß~ât»)k˜JlÚ:F0üìêv§°§¾1à"O<´„ï±1tù¸¾ Q¸û?ŒìjžÚ­{•ÿZ‚ö¥¼¿?:(%D@F›€æÔ/c4߆GæŒ-ï¼óήߵe+}@"sÊ+Æ‹p`œáFÃ!Î1Pë4ÄiQ˜ÇcÒ`,Ç{1 Ý(A1˜0a‚{7‡iò¼*m&(;ûÙ^úýlV±­Ø•å Ï"uÐj[ˆVm8õ|‘.ŒâÀžäá“gÑz£Êu[L;a¬?÷|fq@^`žKÆÊ3gÎÌ‹V÷}¿ÛdÝÍÆàƒæå¬äaÊ I¤W²Ë°%î·xß³} _TŸ†…E¾O£_ŒÇƒ,¿îÕ_R˜÷—¯R±!0L…9=öØäD+5ùBiÂêC=~Õn«ŠJM}Ú(ƒPº­³Î:nŸW”þ·ðÈ„ŽÔ©À` ET¬ aEß;ï¼ã.ÁªÑºŒ®Ì!Ô´îÈ2ëN½.YⲟOž¢Å{|¯0¯œ³j”Õ˜?ûÙϲ‹/¾8Y&â]tÑE.ñ~þóŸ·\IS—ÑèC·÷c¯B”åÞò“ü¡äñ+]PŒßtÓMu øò]zÅå;+«™ðÇ|ýgö†'¿¬ÞeÏ`òï ($QŠR”ÆK0ˆÏ3Ö`µúÓO?«vŽb5L›sŒzbÁ&á½);+ý›!^‘ÊJf?9IM}]7KUQ(XɆ,þó×ôKaŽ9œŒ…gïøÈ3`>dƹu£ï T2…í¶’¥*ÆEV°Ç÷ ?c|ã÷NÇ çùçŸwûzñŒ è¾üòËk jë¦6¼ÔYesúÚ0ÿ±Âœ‰*užÝì#ÆåùL…¸O¦æYâZ®á9Iõq(ÓyÆRŠßnÊêóHY:è ŒˆxîÀ`Àº‹tJzÞ7A™‹ñXêòA*ÍÏÊ:VŠs}È!‡8¼[CãXŒ9yçy.ëÅs“8½¼Ïa:œ·R˜3Îf._wØa‡5Ü¢S%(÷8ôÐCÝ|ò+T¥­À§ßí¥ßÏfÛJÊ0GÝd ñóÅ|&e€Šržq~Ÿy ãöTh6GÆKžÕâÀb ~ãÌ ™o ýn“Eò0Jq¤0/_m[n0("½–å ¯ÀCcØoqŽa^‘ó"¡/cÞŽL—~Hat Ha>ºu«’‰€ˆÀ@ [aÎàWÁñ §Ùg¯8gòÄÊÏf!V΄é’TV#0Ãý"J0Ž?gew*üà?hp¡ÆD4v!b/\¡Jº(ëí^Ωds…|\ÇjEVÛ¯¿þúɼ†Ê/V±û2ÄÇ¢FÉ æ|ÙéýB7I>Ÿ¬ 'Ò@b7ó(ÐRÖ÷yBÒvù1¨öù‰(yžXÕÎïÔm*ÜrË-uu+ÌÃkâg¿¨ÂœûÓŽ÷Ûo?瑃v‚W‰“N:)£æwÿG;JåµeåÙônÌ1h‰Ù3¹Ž 0r@Ù‡¸ß`Åz³Ð‹üÇéãÞs㈉‚ˆÀh¼¾~y䑤BÖ÷¼kyc@†1Y»¡¬c¥°(Œ±«D)3c/\b‡w¯çÁ‘÷¬Ý“8ŒRø¿qóà"aPm²H^F%Žæå«ÉAÉ ðpvÿý÷»m)‘CsÌ1Ù%—\Òt…vh]pÁý{^è‡,‡1 ˜¿„ýJrÿ}‹3Bƒõ¼<êûj¼Úõ§Ü‹€ˆ@i [aÕ+¬°BÝ'ìä³2‘I\3…a3…9ûf1 ó†¸ÞMÝo½õÖóÑjG”õ©UÂ(uS‚·Ôê`„8¸@‹C*®ÏÊ{VîRnö÷õßs„I˜^¬Ä ã–EaŽ[cV•†yã<µG6Š§0ÊÓÔ„»WüX}Þ/<Dz+Ù0l¾ùæÉø>Ÿ¡rË{”èašþŸ=âý¯=V^˜‚C¸gs' sVyó¼ ¤ÄEhLáïÙ/…ylÔƒ2²UˆWø á1ÊvŒ,f̘á„Â×à†=öp[V9wè¼€˜û2 O¶A`2‰‡„T`Bíëšc3…9å 㶣0Ç°‚¶íë”#îþ/µž9bc<„ÞzQVŠ^ØG¾YŸ <ïqŸÏ³‡væ½È|>#<ë¯%¼ãD@F—€æõuË»„÷Ü&›lRçÑ%ì¦2vØa‡¶JªO­ñSÇJq.yz¡1ó­8ð>e\2a<’Z_Óàœ÷ª¼XYÌøçœsÎqó—øýÎûõÖ[o­üµSJPÆÖx¨Iý1ã}î•sä§L sÊ4ìq5yˆÃ ÚK?ŸÍ*¶ä ñó³ãŽ;ÆÕÓögž;ž“8í<Ãl<¾Í6Ûluñ™ûÅãb¶´ðÏëØÚ)¾Ç–[nÙ_ÊD< Ìã9tCä?1¨6™wÿQü^ óòÕê äÔ;²ªW\ÑÍgy3¯f{F¡ J¬¥Å¸÷xÞö‚ý”åÐGaÈx'î‹øÌJs¶vP}R˜~«„" "0eP˜cé‡ëÛfJÎÔÀ‡ï˜Ôá;^ èá5S˜³*8^øßePVz«Å0~ÞjBV…‡ñüyjå_¬÷qþ XòeÖ¡(OIåe¨”­‚Â¥ /_xdÅO6Ø`ƒ†¸¸ C¯øáª>ÌSxΊò8`5Æñ礄±€¿í¶ÛÆI»Ï˜ðÊÀ½j¼ûî»ÉxÝ~éŸÜŸû€Ð²Ï£?âN3e­Ë>ÝxQ ^,˜iWaγÊ3HZL†Bå»ÏÇ~(ÌaïÑ×ÌHÇç'vF_…bÜ»¥÷ñ8òÊiܱ{®ñJ*‡ÃkšÃ'œ0®µÖZÉ 0ÊZ”øì3Ÿ qûo¦0ÇkB˜÷¢ sÝo¼ñFêö®}§ž©Ð˜¦e½æškj‚¿•W^Ùå…}ê wXNT¸¸C; ó^ä?¼·?Wñ,æqö×è("PmR˜7ÖïpÆKÉzWÀaîÏñ0ŶOílsS¶±R\zÆf~œIÙRc'âl¸á†uï5ayn˜ã{„Ÿ=KDAMÚlEÄJoÆ"ä‡ïá…÷+ýï¸ãŽ\#ДÔ»\ÅíjøÇØCMÆ7¡1@ÙæÃW‡õæÏÝ^úõlV±­`|éŸÌ›ûú*zŒç0¤ÑJ*0Im“€ak¼‡*nÂ`üŽ<ŸwŽx‰ eŒ©½1/žåŠ„A·É"y…8R˜—¯û-7àýºêª«& hüsËóÌûõN[=VÊØg²4Ä?¾lŒ&Nœ˜YôÐIÙuMyHa^žºPND@D ÒÊ 0 “fY¸Ð[tÑEë&\~ “wÄrº©ÐLa®.÷×29MÝ'¥(B¸“Š‹ò:pq˜ŠÏ~”? y _ö3 ãrÎþÒ§OŸÞ ”íDaŽ åW‘?Ü:…¡“ûå­êÇ 5Ûl³MCÚpzÅ/V†õ—r Ž"/ŒãϱÞM…¼6”²ÊO]߯ïRB`î…¢Þ ä}Ù˜€„îÖ‰‡ËÏ5ÖXñ`•yü¬µ£0GX‚¢*¥”¡ ÷$ôCaŽQBl+Hß¿{ýÿظƒ~-4f©ý>³TAI»!l¸r‹:[wÝuݾ]aÿAº¸L ½R„÷ŠÛªôñ;U˜#ÔnØo5öQzQÖ­·ÞºöÜbÜ‚° ï/Þ‚ç nÿí(Ì{‘Ï"<’n,4HõYá5:¨6ÿ~æùW¨'€^ƒöØcÜí—èϳ¤ 6ëS{ÿS™ÆJ©ü±‹WŸ{(î;„ã~Lç( ãñBnþÁ_?ñ.ŠÇQ(å1¤>0ZØñ^^H)AQˆs]ê…дiÓœ*o4P6…9eƸ:ñ Û‹ÏG¯ŸÍ*¶•Ô|p§vòˆ:>bëW‚‡ÏåUW]•›&ÛÍ…q9Ç[„>QãÑŽï™ÏÑOðÎal_Çv >pOßÐ Ãj“EòVå8R˜—¯öú)7@nÑœ>Ù‚l«­¶r[<òÆHÆ/rÀ˜ /3çŸ~Ûcܱs7„a²áÌÝÉ?å‹=‘/~c[¿)Œ.)ÌG·nU2(²(Ì}¡qsŽË@öòJ¹éö½øˆr(åf§]…ùw¾óÚ`2¼G¬(brï¯ëã£ÜK…þð‡É´™È2ù CžÂ7µXx]|Þ‰ÊÎ"±;ôNî‡2Ù³ ìq£þáV8ŒÃùG?úц}¯øÅ ÃðÞ)åaž§0G éã„Dz*̼Ðür·KVKû•'žxbÜ,€%N#o%5ž¨cV,ßu×] i…_ôCa»¶&ßÍß>?^@ëËÉóÔ*à) GóÌ3n‹GÆD´‡Ë.»¬N©ŽÂ™ww‘÷34™¯ûgœaè·,y/Û{RF<×±ußÝwßídˆÞHÇ÷I|f¼Ãv= £I@ óѬW•JD@N l s0iFù‚õ l=~Óìxøá‡7ðë—Â׶¡;Á0_(ûSår/<÷ÌSø²ïP;¡ö%—\’›Ï0Ïœc…†vï‡.eùîïÃÀ7üó߇G³±³Wüb…axßqT˜S×ì[O>B†.ê½'\ïÍœ93l"î<%J)ÌÙëÒ+ÁÙÛ«Õ¤ÍÇ¥žP²÷"<öØcuÏB#ú¨V‰nØ^ÂUÑÍ®õìüµ¬Lï$à6>Þ4`ãÕUï¼óNÓ¤ãö? …9üÞ÷¾WÇ’:@ êC7eŃ€"ÀgŸ}öqJVÝý‹ žÚU˜w“Ï uÄ°À·#Žl   "0º¤0/V·l‘ƒ°ôCÉ5~ýÌg>ÓTÉÌòæü6ȱ÷‹ÞY¼ÑîæQ<5ûK)§ÜªÆ÷ ?‡ïÎQŒáacèßþö·nÏbÜÂ{Zxm«óN• ¤‹a y)£Âœü »­‡a´î‡^<›Ul+“'O®¯ñüàU«ÛÀÜ,~.ùÜÌS^Ââm¸†-ИÿxÏpÌOðàÏzlôËx¹.ÛyþHçàƒö—4=–¥M6ÍdE”¼|×/¹ï^¿²å)/DÈÒáÞËæðª†,6ö˜¢‡!Ï8sjä7>ô[–ƒAÜ2Ë,ãúú¶äO_…N<õa÷ƒxõxûí·}6u!R˜Peª(" "0LÃT˜3 i¦c†ûeV•2XK sÂÁOʳ_ s”¥á½Ãs.©pË-·ä^sá…Ö]Ò+…o» l21H…9+]Cvá9ƒú+®¸¢åßõ×_ß |ë¿Xaæo\æ;½°$ä±óÎ;»6Lzï l•R.U˜3ióÊyÜfï½÷ÞMÿØÏÒç‰É^÷`â´~ùË_ÖÒ$m eRÍ8Ýx%>ÌŠ¬¹}8ÆÊá"i‡<Òw¢äÓóçX`oºé¦Ù#<’›dÜþ‡¥0gîóí¡²¿›²Î˜1£.íÃ;,—GÑÚU˜w“ÿfyZ|ñÅëÊ&…y3ZúMªO@ óöêð•W^q+É?õ©OÕõ•¼gx×3Giš)Ì9VJå‘Ýþ}É‘¶Ñì/ŒëÏ™w=ÿüó©ä“ßùëü—é½ Ý(AÉJºazo*s[Ï0Ú ÷Í Ý<›Ul+©ÕÙ¼ øé&¤¼Û¡<Êó,åï•ÊÞÒØ‚È{cŽÜ;ûçßÙ¯O|¦_ŹH([›,’çªÄ‘¼|5Õ/¹òVd)Œs ¶ ¬8gìã•ÌÚ#/À#L^`ź—7°R>\àÐOYÆxx±ð}Í[l‘a¼ë\zé¥ ÆnÿÃR˜Çù`¯Pë´¬lå2A(ÐmhWaÎý:ͳ¼²‡[X6ïN³Ù5úMD º|?_Ĩ«º¥lžsÞ—7ÝtSƒç¡¼«c2>Om„à·Yh¦åºA•â<â½ÉLñŽGY\ä/ÜãÔ¿;Ž:ê¨8ùÜÏþ,“Â%@jë®ÜÂôø‡²¶Š9¨ö2¨g³[…ù0Ú Þ¸üªNÿü g(¢àjÖTYîÓólj'6»Äýöæ›o6ô‰ä‡gšt8OÜâ™)–°ºÕï'ŒÜ©ˆÀ ÚdK#A óòUl¿ä(¬yfwÝu׌ÅHEž4ÙzÁÏ#‘¬´ÒJÙAää (ªé#1`è| }Fîaè§,O—¡ì‡ùw*ðN¸öÚkk :|_ÈÞí £G@ óÑ«S•HD@†B`˜ s) XØ÷¹H`‡Ž=Âý@'<"(ŒC¿æ(7pSÞߟ3 M…f.Ùã½™{¥ð-»Â ToÁêùù#îà: ½â+ê|Þ8Ž³ÂV)wßLöüJ-¶ˆ•š¾>;Q˜‡ì;=ÇmW»ÁN8ãÞÓZ…sÎ9§®(ê +í°|ì#˜Ç±Uøƒ#Vˆá9"% ç^¸2 ]êûtãö?,…9¸ÉRK-å³Xw줬LøCáýzl^w“:Q˜“l'ùÏËïK¬çCn©mò®×÷" Õ# …y涞XvÙeÝ>åEk±(‚×°¿äœ­]š½[)A5VŠË‰¢Þo5‚†Eþ(Ç Ptu[_[&…ÿzÅëPÊè6ŽÛ‹Ïem+”mPí/7ƒx6»U˜Çõ=ˆ¶‚‘Ój«­Öðü}ÿûß³Sø3izEuølÒ' ¾Í†×úsö ÆØ(|‡bÍÇ‹E pÕ&ãüËg)ÌËWÓý’ø}ů¹æš¶ Í\/ŽK,±DíyfqÏ÷Úk¯íþ8å¡è‡Û4pÃPa÷|e9áª|”úÍæ︜½V ›)jDн¦” Z웇~)̹Ϛk®Y@†ù`âTÀ½x/<]öJáۉœ½†Ø3¸Èû …¡“û±OdÈŸ/´ÐBÉÉxx¿¼ó^ñ‹†>oÇAaÎþNy=°Cœã>å#‚Ú{ï½7ïÒ¬¨ÂœÉݤI“ ÿ…ùaâ_ÛÉê"”˜~PŸþã?ž[6ÿC¼÷9JwÖ­BÜg±ïf»þ”t•鸇śJ /¼pCÝá²>qû–œՂž=G\®ùÐmY¹>ÜîƒöûãÿØ'ßòHŸGŸ· ÚQ˜w›ÏøˆÀ"dÆ9+D@F—€æxsBË{¯h`N¼^…ý&ï”oyÁ+”†=V ó‡rÏo›ƒc‘½Gýõ¼7Ph† »\jÝ™ áuœ—Ya~ÕUWel密+RÎNâ”±­PŽA¶ïi­ßÏf¯æƒj+)9Áª«®ÚÔh§Y[d>¯Z_l±ÅÜÊÐf×ùßî¼óκ¾ |¾?þx­áxÊ)§$¯cn˜çy,Ldm2¼ï8Ka^¾Úî—Ü`å•Wv²™"Æþ1 ÏÙl³Í„ýýÌN;íä< ÆiôS–³üòË×ú¶lØê#Tð3ÆÃk¨ÂhÂ|´êS¥¡(ƒÂ_; X¡E¡°¥öŽ•O>.Ç”‰½ÒÃ8þ<¥(bfÿ{xÄÕ|*¤Œ\‡B,vOÖ+…o' lòªË"({ÂÐÉý6Þxã$G&Ö¬¶mÈcj_ê^ñ‹†a=²Â|«­¶ruÂj‡¼ðꫯfìƒ2ñç¸ûÃ’7/U˜#¼¥~‹þ…+)X™_—Z ‘—Çð{„á¾lï¹çžðçä9åG0^wá…&ã†_ÆæyýIxM|N9Y5žz~Pšò}¸çyÄc@âöŸŠã¯Á),+.ðS!RoXa¦·zQV„ aúä©H[aÕ}Í"‹,Rgœ+ÌYÙŸz‘ÿTÚ3¢½ÙQœ „T]R˜gÙSO=åúsk­µVËëâ>·„íVÕ‘_ÒJ&Í>ø`ÝÊjܒѶÂððÃו›½Ìâ8>>®Qž ú¸On¥0ç~Þé#¼‹WÎw[V¶Ñó>Çsd'žxbnY)3ÊòÝwßÝí øá‡×ÅWå`¼zUWqúì-– #Ñ& …yæV•ãa†þÕÒíx–Aö›¬îlÊ6Vâ}é Š1(â '.ÞRb¯:´«Ÿþô§qÔºÏ(ÂBvœ·CÖ%ÐâCÊkÊç?ÿùW5þ £#<ÒyB¢ÄciîÃ5O>ùd!á{ãÒß”­­ËA·Æ;ƒx6«ÜV#Ï9çœuÏsZöôn'àQj¨K‡­ð^xá…v’Éößÿº4x®q±ÜLù†‹ã”œ¦ˆ;öA·É¶`ŒPd)ÌËY™ý<ñÄnÎßm‰é¿ñÁ¢:ÝxãÙ}÷ÝçÞ•á¼¼Ûû´#ËÙn»íêú§”l.ÎO(ShµíN|­>Wƒ€æÕ¨'åRD@JO , s&ÐS¦L)dyŒP&ÜO‡ÉÛÜsÏ´lœ:ujÝ@*æ¼öÚk õ“§ÔFèVâ~(L“sV¤0YÃç>÷¹†¸¸šaWÆ%Rœ.Ÿ¿þõ¯ÇQ›~F ™J‡ïü¾hp`u>V¢EšÍnØÉýX©œç– õ=÷ܳaµò¯ýk§,‡5ëØÕp¯ø1Èã—r+ïä¯Åås*äå3t9^‡KoÜ:¢xå‹Þ~¿âi3¡ÖĸÀòåäȳÒj¿ËÔ~V'tÚ™dµs¯Xù¸Ã;ºœç)<Ó^› °±.û6ÎS†=­nî•°Í\/"”ò\ê-åE㥗^ª«[¼>  Žö 6Ø ..Öç)/í*Ìaò<’&{±‡¡e6mZƒñŠžç”«6 ƒ¶ß~{÷Þauy莼!lŸ ÞOäÓVêùm8z‘ŸnxŒ ‘ø¬ "0Ú¤0_ Èx–>wâ^¦ÆûqK@Á„’9ì»O?ýô8ZÝ粕~ö³ŸÕÞ—Ì9Š¬æ¬+ýÀØÀ¯†Y ´‹½J…×2î ãsŽg“^Þ³qú”±Àx–í¦¼ë}\ƒ‡û—¢$Çà€õ(ã14ë…1'y,[[!Oƒn/´­A<›Un+Œ =ôP·zÓ·wŒ88à€º¶Jýåä xúò×sÄ›cÝvŠUúÑ0­xžJ3ë“ÏW«0è6Ù*?£ú»æå¬ÙaÉ Ú¥A_Þl<Ðnzaüvd9,ö û¦Ã;,Lªáœ1Àâ‹/^»†ñ¡ÂèÂ|ôêT%¡(‹ÂœÁÊc܇µR¶á²Ø[¨s“0 ¡ÐÃÌ݇ƒª”[å¼}ɱÒN ÙÃ;µð­·Þê³àŽLÞc÷d6™t¦ò»dóù^j©¥š*0ënj?àJ.žèú´˜<tÐAÙ†nèQë­·^Û콺û#ú|ÅG\;#ÀÂÜi§–í¼óÎNÁò….¡WüX)çÇÝBû{ï³Ï>ÉøaSûWÇî?}Ú_ùÊW|’uG¬óœøx¸DW××]ÐÁܘ‡ JV"çÚn¼:÷ÔSOÍ‹î¾ÇÐ$åʽèªíf‰·3Éj–Nü,žÏUÎq›‹¯á33öùó×qDèì·1PW‡­§lc%\‘"üõe`¬ÜiøáXKǧǪכnº)7IÆŠ>®?2^Må&ÒäV¸ûtý‘±Xjn'Ã/8ŒÑ'L˜PKç»ßýn]T týŒ{ð<­³Î:my@«KðÏÊÖVÈÖ°ÚË žÍ*·ê†ù"óóPÖ1ï¼ófl±à-‰Æ¢ŒÏ™C†í¶bJÉâ4âÏ´ Kü3‡0†î­cu füuÈ›Zð «M¶*Ë(þ.…y9kuXrƒ2ÑhG–ÃÜ6T€cìÞÌȱïW™›7Ó”‰‰òÒ)ÌÛã¥Ø" " 9ʤ0gR…‚• ¬6Ýû0ùbEm¸O1 ¡I“&5dXÙˆ•òꫯ^›¬ùI›?n¹å–«™`¢Ä@ñkÿ{xdâyòÉ'g ÌÂÀµ ¾Â/¬^Á]-}ßMž<Ùõß¾>92qÅ{à>ðœ„õ !\££,çÊñ½Z}æÙòÏsÄpîÒìÚЈ™G³0Ì6Ù,_£ú›æå­ÙaÈ ÊD£YãÆp^6H?ÅÖ·ÜrK]?Å»øª«®ª››#?Žå°eâ ¼tN@ óÎÙéJ€@Yæ¡… zPÔ¡hbU-«Y9®LE9ÇŠã”âŠÉ$i„0?ÙóGÜä²Z%+ %—\²6!ôqÂ#ÊV:Ç…ÉÝwßm¼ñÆ5…/åaR‹ûlòͽ|ZXB¢h‰W® Ð`…»wWçãÇG` „*P¨†«’ãôPÎb,€›à^„NïÇJTVãÆ.¾ãüò†×^{mÝ@·—ü|ûñŠàTPœÑ~XÅÏ yV¢HMÅå;ŒP²¥”sþZ„Œ¬>÷ ¦Î}ŽCzaèpÊ)§¸•¼”ÃI÷à•$.·yÞâ@»ñ«YÉ_JŠ”Ä(üynÃ2øs„’+¹ÏÁߦÐçv&Y… "!`• W\qEðkóSV„°‚_­Íóˆ@*eEàëÛÂ1KqÿÐüõ¿†JXøÒo²šœ};Ï<óL×wxïºÎ =ýåqÇW×ÏÑæ¨;\õÓ_®±ÆŽý(JjÚ§76©/éûûÕú¼pì´¬L¦1²Úl³Íjýx˜nxŽA+ÆS[oøüQß<Ÿáu´qžmž—éÓ§»¨½¬+oÊÁ}¸7÷Œ>žŽ" £EÀyóúóÑ*m~iPŒÓÿñAä¹0Žg¬ÆX„ä¼kx¯û9GŒšPF¥Æ2e+]vÙeN!Œ!Vø¾¡Ì¬šÇ8«ˆ'" ÖðÄû oVaZþœwãAÆ,Œ ðÂÄ܇9IžÁ1s æCŒ1˜l' 0dÞ…q^h àóÑrbÔÆØ’÷?s(Ž|æÞÌ¿üû0¼ŽüƆÙyÛrtÒIídÛÅ-c[!cÃl/Ü¿_Ïf•Û \RƒŒ:0º÷Ö´e 8yéÇ0áùÃ8>ÜŠ~ ÙÏ>ãÛnós?Ž=è5K¥,Ê{òŒÑK^v›ÌË×(/…y¹kwÐrƒ2ÑhW–Ã<C¹å—_Þ[§ SAîÁb ÿ1ècq}ò;ŒüSòã2qP^:'0 —ÚŸ‚ˆ€ˆ€tEÀ*MŒ]Ygì¾Rƺ±î*­v/¶‚*cûÆfŒUÔ»šÃØ •û³«>\rV‘bì$ÑØÕ‘Æ*ZŒþ«¤4V±bìÑX›± ›†[[·¿æÆolø>þÂœŒ]Ia~ò“ŸkÿÜð™{?V°fì c'’ƺý3v[cW‡+È1ÖªÛX±(câÆ ãŒèºr…éX+IcìáWMÏ­A€±îÙšÆáG¸ÙÕšæòË/7O=õ”±Š8ÇÑ*æŒUÚ;ˆ4vÒm¬0ªeZE"ts?˜Yãsûí·«PrÖÒÖ݆VH`¬‹fÇÐ =ÀײÔK~EÛ˜sÏ=×ØÕàæꫯ®å%ïÄ·»òÅÕE^<ÿ½Uf«äô|˜)S¦»×Xa ±‚Jc® m©vAÁëÝØõdæ^Á³ÂófWë4Äá9& »*Úµó8í¦VˆÿÔð™ûX7~Æ V~kõ…5¸0¿úÕ¯\4«”vyjuM;¿[C³Ç{8NVíú ò[$XÁ¬ëïèk|Û~ýõ׸¹vl¾®Üd“MŒ|«|.’l2œ­â×õéô™ôMv?rc'•Æ Î ý•»ûYa´ëSÃg)N”¾yêÔ©æþûï7voì fcâ®ÿ° nC_Nþ­–¡_¡?¡£ ij‚|c'°µd­‘‰kËV`ãúJòg…õFVaá®±†AÆ ÙUN;y6Ö¦v}xÒ˲ÒþÉ ýuéf¬ÐXE½ãeð†?úLëNÝXa¤áý”¬…kÖÁØI¹{,ºè¢Æ®dtÏ-×z™ŸžQká>ÚÕåæ /t}¾ÿ]GÑ$@?Θ“~…ñɸëfÓõ³Ö8ÑXïE†wsëÈÍ5x÷2¯ ðæ}Ã÷/ck+l­{gyŽe+‘o»:9~c|ÂXÈ ŒÝøÙ—#uäÌxÒ·ŸTÿã køfìj}76`üÝ*ðn·k——Vqýïð~àÜ;Ø׫#ïsÆŒa°žvÜû’vÂ8‡±Á*]Fmy^ƶ¸úÊ+¯Z{a|ØÏg³ªm¥Ycb¼ŽL„ù;íÒI»Ï±“1ÐF ÖXÛ‘s3O³&Æ*Ü€±~·÷ soÆÿ<óEÓ¤/A^ÃÜÃ!¹qp*/Ãn“©<úwÈ©h+ÈR¬Qí¨·’å¤Ü L€:‘åXN®ÀüÝzÐ3Öˆß ?DË8ˆù½5˜tsxú$äÎ|VMR˜f½ªT" "0pÃT˜ÛzÆ®P0vEƒS² ,Eˆ…`Ëîe¬eµS Ø¬ÆZM»RÀMQÌ èàsž²ŠA&iµ \R’{rM«€ÀǺ ΆÀ‰AšÆ1€CX…be)ƒ3©|3˜CAS40a-ªT³.Ûœ’¦L°Q^¡ '/”‡rõ2ts?&Ø0´«7ÝuCþ0œ@°¹¨U:Qî˜a/ùm?p\l±Å õìûÍ8úöƒÑ†­ÂoÚº-h#ð¡þ¨;çÝònÝRµL†{¦&Ô÷‹/¾èX¤„ô<Û´½¢áõÜn¹R7<Û½ ”Á®@2Ö»kw`ÀS4 ¬Û6\hǃоi× Äm»hú>φô›Ôí™úEhE _ž%î—ªOŸNx¤X‘.Ú!ýý‡]^SÆ"È#]ÒäÞÍy䧯$<÷üQo¾ÏD‰²½YèGYÉuCþàÆ=¨þ(sžò>Î'eCYNÔ}6F?a™zšÖ ¾3ŒB9aÝÒ9å~œ7}=R˜¿_§,aˆc4”Nôé|Ïe9ïC½ŒÍÛЯ3¦âý“Ê8V"ＫšÞ;(¹›Þëv;”fQê~cŒÃ"s-!ÂkÆ8ECQÞEÓ ã¥Æ³´Æ9´xØjnž:mÚ4§„ ¯ou^4ï©|v¿ÆÕ”mX텱簟ÍVõ–ú=UG½l+©{Æßчyù²ÚóHòÁ¸›g‹|"#alÏxµ—ãîÇb…vŠYæ>(ñó°Ûd^¾Fù{)Ì«Q»ƒ’”‰F7²/«`lBÅ|ž~‘qý$sxd ­ÆCe⡼´O@ óö™é a*Ì™ð1dr+ˆøÞ+P˜$2DX¥ŠÊ’%BgZÑ>RŠØÎRÔU"Ð9ѬÞfµ‡u±oìÞY÷KºjÛׇ®ü€íi÷Ýw7]t‘k“vÛ'ð߯\¡3Q" …ùûµÉø›¹cï¼þþ’x½6¥ö4ÎeaÕ¥ÝÌR0ÞkæQfœ9µ[öQ|6‡ÕV˜ÃCh‡€æíÐ*O\É Ú« ¿H oØ^jŠ]R˜W¥¦”O(9a*ÌKŽFÙ§p«¾ÝvÛ¹H¸×ßk¯½âé 4Ë.»ÌmÓUýGáÎ{½ÊhÐeÒýD@Š¼8+Å<xj±{¿;÷׸VÿVÛe奩ïG“€ÚÊhÖ먗J óQ¯a•OÆ—€æã[÷*¹ˆ€ô”€æ=Å©ÄD@Æ€®ÙRbòäÉn¿möòÜvÛmÇ ä*bY °W:í—ºtasöWR˜O]«¤ý!ðÈ#˜)S¦˜»îºËì±Çæ˜cŽ)¼gsr¤TËJ@m¥¬5£|µ" …y+Bú]D ª¤0¯jÍ)ß" "P2R˜—¬B”J`_¬‹/¾Ø­äeÏî8Àì´ÓN¹î_+Q(e²’®»î:sôÑG›éÓ§»Uå(Ë\pÁJ–E™蜀æ³Ó•"€w–µ×^Ûí[Žç !ÛÙs]LJ€ÚÊøÔõ(–T óQ¬U•IDR˜«ˆ€ˆ€ô„€æ=Á¨DD@ÆÀ[o½e¦NjŽ:ê(3ûì³›í·ßÞrÈ!ïi>†Uä. œqÆæÜsÏ5o=ôP³ÑF™ &t™ª.¨")Ì«XkÊsYüñ4x ™8q¢Y}õÕͼóÎ[–¬)%# ¶R² QvÚ" …y[¸YD Bþ?ÿÿ’9@IDATì¸$Eõ·k ¢J–$É É9 JRrÎIrF K»‚dP,aÉ’„%‡Q\X„• í¯Þú¬±¦nÏL÷tOþÕóÜÛ3=ÕÞꮪ>çÔ©a‰ FAD@D@ XtÑEÍèÑ£Í /¼`\pÁ‚©ér,Ÿ|ò‰yôÑGÍyçgÆŒcžzê)3ùä“Õ¶#x\rÉ%ÍŒ3ÎhöØc³Ì2˘)¦˜¢#eQ¦" 'ðµ¯}Í|þùçæË/¿4N8aç ¤ˆ@;v¬™nºéÌÄOÜc%WqÛM@÷J»‰+¿²<óÌ3fñÅ7K-µ”yâ‰'ÊJV鈀ˆ@Ç “¼ãm ˆ€ˆ@_¼/šQ•è ”¯½öš7nœYyå•ÍDMÔÁÒ(ëA"0jÔ('ÜŸgžy¤ ¤†W]E …€æ)PtJD@D@D B@ ó }è3R˜÷Yƒª:" "Ð)R˜wŠ¼òrHa^G¥"" " ýJ@ ó~mYÕKD@ sÝ" " ¥¼ŒJDD@D@D@D@:F@ óŽ¡WÆ" " "Ф0ï‰fR!E@š …yÐt‰ˆ€ˆÀPR˜e¢3" " " " "ÐK¤0ï¥ÖRYE@D@D ý¤0o?så("ÐR˜·‡³r¾' …yß7±*(" " " "Ðç¤0ïóVõD@D@D  )Ì Ôå" ]K@ ó®mLD@z‹€æ½Õ^*­ˆ€ˆ€ˆ€ˆ€Ä¤0‰è»ˆ€ˆ€ˆ@H@ ó†>‹€ô)Ìû©5Uè )Ì;_Y‹€ˆ€ˆ€ˆ€ˆ@ ¤0/¢’>& …y7®ª&N@ ó¿T}(‹Àúë¯o^yåsÇw˜¹çž»¬d•Žˆ€ˆ€ˆ€ˆ€ˆ@›Ì?ÿüæ‹/¾0¯¿þº™`‚ Ú”«²è/½ô’Ùpà Í"‹,bnºé¦^)¶Ê)"  HaÞ‘"ˆ€ˆ€d!ðì³ÏšÏ>ûÌ,¶Øbf’I&Ér‰âˆ€ˆ€ˆ€ˆ€ˆ€tG}Ô$Ib–[n93lØ°.*™Š"" " "Ð >ýôS3zôh3ùä“;¥y7”Ie2Ha^E¥!" " " " " " " " " " " " " "Ðs¤0ï¹&SE@D@D@D@D@D@D@D@D@D@D@D@D@D@Ê …y•†ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@ϼçšL(ƒ€æePT" " " " " " " " " " " " " " =G@ óžk2XD@D@D@D@D@D@D@D@D@D@D@D@D@D  R˜—AQiˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ôÜ ó_üâæý÷ß﹊ªÀ" " " " " " " " " " " " " " ýC`ºé¦3Ûn»m¡ åV˜¯¹æšæÅ_,”©."Zh!s×]wIÂäV˜¯»îºR˜B®‹E@D@D@D@D@D@D@D@D@D@D@D@D@D@Š@a~Ûm·J&·Âü™gž1Ÿ~úi¡Lu±ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€!0Ùd“™Å[¬HùW˜ÊM‹€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@—Ƚ¼KÊ­bˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@!R˜§‹E@D@D@D@D@D@D@D@D@D@D@D@D@D@z•€æ½Úr*·ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@!R˜§‹E@D@D@D@D@D@D@D@D@D@D@D@D@D@z•€æ½Úr*·ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@!R˜§‹E@D@D@D@D@D@D@D@D@D@D@D@D@D@z•€æ½Úr*·ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@!R˜§‹E@D@D@D@D@D@D@D@D@D@D@D@D@D@z•€æ½Úr*·ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@!R˜§‹E@D@D@D@D@D@D@D@D@D@D@D@D@D@z•€æ½Úr*·ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ@!R˜§‹E@D@<—_~Ùüãÿ0 .¸ ùÚ×¾æOë(" " " " "Ð#žyæóŸÿüÇ,±Ä=RbSD@D@D ý!œtÒIÍ|óÍ×ά•—ˆ€´”€æ-Å«ÄE@D`pl½õÖæõ×_7×\s™sÎ9§âª©ˆ€ˆ€ˆ€ˆ€ô å—_Þ|ñÅæñÇ7L0AŸÔJÕ(‹Àk¯½f¶Ùf³À ˜#F”•¬ÒŽ¼ãM ˆ€ˆ@XtÑEÍèÑ£Í /¼àV™÷G­T xŠúüóÏÍ—_~i&œpÂÁ©¸j*" " "‰Þh_|q³ÔRK™'žx"Ó5Š$" ½@@ ó^h%•QD@z€€æ=ÐH*¢ˆ€ˆ€ˆ€ˆ€Ô! …y8úID@D@DÀHa®›@D _ HaÞ¯-«z‰€ˆ@› HaÞfàÊND@D@D@D@J& …yÉ@•œˆ€ˆ€ô)Ìû¬AU )Ì+(ôAD@D )Ì‹ÐÓµ" " " " "ÐyR˜w¾ TèfR˜wsë¨l" EHa^„^—]ûÅ_¸½Æòkâ‰'6¼+ô7±cÇšóÏ?ß¼÷Þ{noém¶ÙÆL3Í4ý]iÕ®í:¥0ÿÇ?þaþýï·¤¾_ÿú×ÍDMäÒfÇþóŸ-ÉÇ':Ùd“¹º´#ŸaÆùlK=þéO2·Ýv›Ùu×]›Ú÷ò7¿ùy饗ÌÌ3Ïl¶ÞzëRËÖm‰ýå/1>ú¨yä‘GÌ”SNiŽ>úèn+bϔ窫®2³Î:«Y~ùå;^ævõIqEßÿ}óä“Oº=äþð‡?˜( %ÐÉ9Q'óJ¢õgþïÿþÏüë_ÿj˜ÑL`&tR/ÏûLx]˜I’$æÓO? O ù\ëÚ!»üÄßþö7÷Ì?üðÆ>àâ‹/îò«x½@@ ó^h¥þ.ãþóóÙgŸÕ­døžV7bƒË3˜×?ûì³æÕW_ur¹o|ãfÚi§uò—¹æšËøw¯×_ÝÜtÓMî=‡÷:5ôù9öb{Õ«ï=÷Ücþüç?›í¶Û®Ònõâ§ýÖËí™V˜€æ1}g,xûí·Í˜1c crÍ©¦šÊÌ6ÛlfÙe—-]ÿĸûâ‹/šW^yÅŒ7Îð}üøñæä“O6óÎ;¯Dš& …yÓèºï«¯¾ÚŒ92WÁÖZk-³ÿþûçºF‘{À^{íe®¹æäÁjß}÷5p@ïUD%îjR˜rÈ!N8Ñ 8'œp‚Yj©¥\Ò(¢Ž8âˆVdSIó’K.q“¼väƒr±Ì€°éÆo4^x¡Ú{%pž<^xá³å–[š?üÐ ˜Fçò®Ë ÄsÏ=çöûzúé§Ík¯½æ ™˜ÜsŸÝ}÷Ý]_‡n, ÷ÞÊ+¯ìd›o¾¹Ù{ï½ BÔN…võI(yFxn8¾ñÆ®ÿ@iÆËé'Ÿ|Ò)]o'çD̻݂‘Ù~ô#ó÷¿ÿ½aÖ3Î8£1b„‹·í¶Ûº~±áE6Bx]A cI½€åœsΩ¥k{ë­·œ’ü©§žrB"Æþ¾úÕ¯Œ2D ()Ì‹ÔõE \tÑEN©\/Æ‹2Œkyg9î¸ãêee¾ýío×”µa¸Dy™Ç3þüõ¯uÐôÉÌG¿õ­o9eÁ÷¾÷=3ÿüó›+®¸ÂÜu×]nÜ[sÍ5+ù¶kþXɰĽÔ^ª±ßª«®êæÔ×^{­YrÉ%]’ú{/·gj…tR"R˜G@ü+Æ»\pyçw ã",lbN9ùä“›Yf™Å0noºé¦…HÑG5ÊÜ~ûíæå—_6}ô‘w1ºþÎw¾cKÓÿ2n+ˆ@³¤0o–\^÷»ßýΰ2‹šûî»ÏYõ¤+W&æt+®¸¢YguÒ¢é\˜sÎ9 «Í|Xf™e ÷‹‚”I S ó_þò—æñÇ7ŽQj—n¾ùf³á†º$ù¼ñÆ—™ü´xé`…v;ò¡½Ê (æN;í4sýõ×»Õ 'žx¢Ùb‹-ÌW¾ò•ÌY°Šä‡?ü¡›ø¢bŠ)2)Z2gÐ?þøc³þúë;…JÍpä÷¿ÿ}sï½÷vA){¯Ü/·Þz«9ì°ÃÜ ó¬Š§žzêŽT¦]}Ò-·Ü⼘   WbñbÚjO[B¦œu2ïÐåJÉ1ÇãxÒH ,°€Y}õÕÍ<óÌã¼’çÌ3Ï4o¾ù¦ùõ¯mÞ}÷Ý!—±BƒßEYÄ) vÙe—!qè[éXå‡R"~6x" <¡ôb@ØôÄO8ã4 è ÓM7]fcƒ^¬·ÊÜ>R˜·µrJ'pçw:™ïE(¢ÓŒ_|qç© Åt‘€÷=æniaá…6(º¯öÜsÏ!QþøÇ?šýöÛÏõÉ.X ÀxÏ8È*;æÿ”qúé§7ßüæ7 ×x%ûÎ;ï\I³]óÇJ†%~è•öÊReÞ)6Ùdƒáíƒ1@3¡—Û³™úêšÁ# …ùàµyZé+‘Þpà ÎωÛo¿½ÿûß›;î¸Ã½¯ ÐÞi§ Fäx<Îî¿ÿ~çM E9c)sÞ y·c ^[kÑwyO¡yóP|€€æ}t eâÍ*bÜýä'?qŠ—°ŠLÐqÑI'…ëC¬|p¬ÐßPÐà"Ù„„¼Ô(ˆ@™:¥0GXÌ H丸 1&pX4Æ!3}'ýæ|`°ŠÄZ«E“¾Í6ÛÌ}ÆKC¸b ….‚þ9æ˜Ãõ£ô¥LÊpá>o\Œp¡“Iùü!@AA*MQ* jG>Ê("ðXñ«_ýÊ)¬Ø[e•UÌ$“L’+y”ì¬è÷ìûQaŽÕ+}/ γÎ:Ë­ ö¤0÷$š;ÂÖĬ¸fÜ;÷Üsв¹›¿ª]}îΨ3ù]yå•æ¡‡ªZ ó Š!:9'êdÞC@´øã+[!(9å”SœAUœå¥—^꼓ðŽB d\A‡+TÞmÂÀXÊjt bX¹‡ËÛ8à̓9×òlœtÒI. F\gŸ}¶3F¹ŒR£Ê#æ,Ôí·¿ým¥ R˜WPèCAR˜¨Ë @Ž¢™#^™x }:ƺ޸9ü-ëgÞÇ–^zi·:-¾f¥•Vrï–ßy/a¥x˜{¢  l?‚AßñvD\Æ"æhx”bìÁPŽ:ê(sì±ÇVNµkþXɰĽÐ^Y«»Þzë9nâ3×@Ù“&Gh”^/·g£ºéw€€æº 0|øp÷®Å;ß 3Ìà݉µ`OìʺJ|«@OÚ•O¥b>Ø pb­C;NìÄ7±†‰¼æNÑ)$Ö ´Â~¤Ù{Î*ƒ’ã?¾ª¾VaÞÕ­Ô)ëxU¹ ‰<ãÖ{Jb­Œûò•X¡¥cÝDR¥]ÒÊ>‰BZ­ë¿¬¡PÕýd•¥Õ¡Ý µú^é䜨™¼[Í£í˼€1"íVR5³·ÆSÉ8äšùæ›/á='k Ÿ¯Uª$V“õÒŽÆ«×î<÷ð‰Ÿ{«0ïh™•yÿ°BH÷ÜHnÐ?mÚË5á}ƒ¹ïËÃ#ógæÍ» VjºäqñÅ×MÖ®)¬/‹~®Ç±Wæí¸W:9'Ê›w;x„÷Q«>S»eBÕ=Ê}j÷8¯›¥]— P‰ïm»¢¥îuáÖëDåzÆî^YÛ¹}ÈF ó^hÝÞ(£æ½ÑNƒTÊ6Ú¨ª¿ó}Ÿõh•X;M¡°MÜ‚ŸV|´ž¿ê¦k·7¬*S½ø¼7ahm]}W®Y{íµk¦ß®ùcÍü¡Û+K•¬{ýJûøûÁº×O0z(z½=‹Ô]×ö/)Ìû·m³ÔŒqÍn…Wé3™;Ú­`k^j·ÐL&˜`‚J| á2¿õÖ[Nק!ßE·Á¢'h)Ì[E¶ Ò½üòË+‘ŸìY—ˆ]P²þ*ˆ#ër+±û‚·µbÊ·­•Tf=E æ¼ÌúþέëñÜí¾«.K.¹¤rí©§žêÎY7m‰uã^9È£0çZ&zô”åy»ò‰Ë÷û7ÞX±ò´[€4œì¦¥Ï$›êÖuR²ì²Ë&Ö…S¥ýú]an]ØWêJÛ÷³Â¼Ýㆇz¨ãË=ÕI%Y+û¤ð™ÂÐÇ÷y{UaÞî{%dØŸû‰ÊïxÕ+¸wkǬ(ïm>ï¿ÿþµ.rÞºÔu×Ûí¨ëÎoÈïÝx"k»[7¿Ul¤0ïÆÖìÍ2IaÞ›íÖÏ¥¶ûŒWõwá¸ÀÊîf+ÈýŠïØ8‹ôñú(AöŠ\ÃçÁ»Î(ë9¢‚´’€æ­¤Ûá´qoá;´{Ft¸Tý•=®_çšk.ǹ óNåÛ_­§Ú”M æ(Ÿ}çÍ(ÌY½Æ‹þý÷ß_ÁtÜqǹ´q¿W/äU˜“®‹(/ýv»ò©W‡F¿Ù}Ö+“]V˜¿øâ‹.IýUÖ!¤‚µïOa!…y*²ž;Ù©ñŠ•Þc±Å«kíÜJ¨­ì“Ârã©Á÷y{QaÞ©{%äØMŸûÊïП¿_¹¼…C¸ëpïÎV+ÛŸx…+Í{!äiw)Ì{¡E{³ŒR˜÷f»õs©1Î¥ÿŸjª©*Jn?Žð.RO¹ÆÁ=óCÒ`ñꫯ^5â<^7H4²Z-š/«{p›»<ëâ=ðÀ {13xáZ³QyãNSß»‡@?(ÌyÏ9çœT¨ï¾ûn2zôè†÷}3 sžÒ¦ßhW>©•Ìp’g8t[ÈX‘7ð|ã>¥û1^Ú¡0GHŃ·Ür‹ë YïÇ3aßÔÊq¤žKv ðr@é/Ÿx≦\Þç©k½6?~¼3æ¸á†\™¸õÑEÇ«2ÊþøãW^²X‘ĸÛîPT@V¯O ëRDaÞLû†y‡Ÿ™0?àeØÏà^o‹¢÷ {¥¡/Ž»ÐVò@Iàçοþõ¯»þ®^Þ{ï½wÕ5\·æškÖ»ÄÝË-·œ»¥|ط׺°Œg¡süF sÞçxoâù¸ùæ›Ýüº–r¦ΗÁ¥Ùç´^¹ô[ëHaÞ:¶J¹9^‹ñ2î±Ãq„ϸiEV•5¬¿þú. æ‡\—WaN¿èݹû²àÑ„­µ²ÈHP,à )–·ùò·kþèó+ûØmíÕ¨~Ì[½òËQVŽ·ïf›mÖ(™š¿÷z{Ö¬˜~hR˜tóW¿ø1ðÈ#l=ïèÂ@Æáú÷haddoR…>$`_$Ìü㪚Y—ì怨:ç¿X…¨±«ÍC=d¬ÂÒX᫱®‡]EmøÍ®Ò0VÉ`>üðCc]`;¡4Öý•±î«Œu•á¾“–}á0v c] +ð6V¨nìdÓÅgžyŒU&™é§ŸÞg[u$Ï|ÐX±±J wý+¯¼âÊ2|øpóÈ#+ˆ2Vøçò³®|]Z;ï¼³±/OUim»í¶Æî‹XuŽ/³Ï>»«—ÿÁ*©ÌÁì¿VgžyfsÙe—UƒµBv,¨›SN9¥Yj©¥üWcW³«H2“L2IåœkÈ`{ì1c…œÆŽqì –! ûra6ÝtÓÊ5þC‘|íJYǶ|¶Ê.sçwú¤k­âÎX—aÆ*Ùw«Ùõ‰aL«82?úÑÂS…?·+Ÿ¸ vïXsæ™gºÓVÑa¬rÇXëÏ8ZÝïÖ(ÁvØa®/²B|³øâ‹»øvYc•mî3}¢U®ÔM'ÏV mG¬¡’±B.7ŽÐßØ=uÝ߬³ÎêÎÓN?øÁ\Ò­GHœ¾o“M6©T1Ì*÷ÜøG¿ËxÁA¹aÁx·ÐB ™<°æêk¦®þÚðÈ\Àº½rãý¿U²UúhÆæ{±/0áenÑì8YVÙ)sÚõƒ>påc®À¼¦¡]}’ÝwÑXaq¥jŒÓÔ¿^h¶}ÓÒä^e~c_xÝÜû…9åàþ°{Bë¦ÍÍoxæ|hvnÃ½ÈœÔ 8ÖêoW{¹9ʱÇëæYÄ!ëjÕÐ[˶Ù9Q³uôuåØ(ï¼<Î>ûlc…ºaC>o°Áî9 `ÞöÖ[o…§Ügë¶|È|zH¤‚'¬’ÀõÅa2tùùÏžªú¼Ê*«kXYuŽ±ÞzeqóЪþû…¹ˆ]‰èžƒsÏ=wƒðš2ž…NÌñ­§Ã|ÙúÞ}xŸ¢Î¼7YÃ÷,Ún,¡O<âˆ#2ÍÓŠr)òœú:éØôÖÈÄÍA¸wD Ó¶Ûn;3räH7FYNÃû]ü¾ÆÜÓ ì•÷Uæ°ôQ»îº«9ÿüóÍ–[ni¬qQÕµÖ@ÔÌ?ÿüUçükœçú_ÿÞâÏÏ8ãŒ.-úYæïµÂ›o¾i¬Q“±J7W‰ãµkþç[Ö÷nk¯Fõ²ÊpsÓM7ÞE‘‰"ë´+Í 2+Õ!Ç«uOøxiÇ^oÏ´:éœX'ÇA>+"3ñžáƒ5p6¼›Ö ÈebÙáyçgvß}÷ÊeÖ#™± ÝÔŸ´†ÒÆz†q²(Æ_äyÌUë³þZE )íÒÌ+ŸöȺÂÀvBëÜ‹[åge¯?{C%¸NdU‚T¹ý¢8ÿá&ãôÓOwdÅ.ŒØ)ŽÇw«N¬‚ ‰W7°jשäc? ÖCÄÇ*«.×]wÝdši¦IMsâ‰'NYdçƘUE>Pv«pR«pðQÜ‘UëgœqFÂê,“ÃrS·8œrÊ) iXoU\VÈØÉsåÏ* «V²*…Vpõ ~¸1>묳ÜVVAãêŠ+m`™!î)óæk Üê.« HXac œ+)êG+Ãp ³’Ç[8N¤ÇÊÊËJÓ•VZ)¹òÊ+‡XSc©KÝ–]vÙdŽ9æp«ˆ<_,¹­Â,™o¾ùÜ°øóþȽÂ^bÔC¡7ôú sV¾Y¥Ž{¶‹of…y3ùµ+Ÿ°lv‚[Ùšguùå—ÒW…ñÓ>³ò“†<÷Ö¸ªÊ{«V˜³ÏãûÞÒwí¸ãŽÎ»ýœ5˜rãý2n{O<ñÄJ±[5ŽAÚ sú~Æ3¿ÂÁ÷‡þHk•_I½=›­k¥Òöƒê$ÖÀÎYöZ¥”ë§×Xc ×Þ~ì£ÿgeŒ5Ìs+ŠÃëóŽWþÚ2ÊîÓòǵ×^»2¾øUDþ·v­’µ’¿oGV»f yú¤<+Ì‹¶o\öûï¿?±F&/®nh_z{T?.0`ÐvØ¡Ê•ZÞ{…¼x–iWæbì[ê¹ZEab\+Ьœã7òfu-Ï{³s¢"uÌ3ËËÃB&l‘Aßå9ø#s3öycõGð^ÁžÞ>.Ï3nî¬B?ŽZúwöè&?Ÿ7G«Ä­xúˆ3´F— ýP߶ÆqôÊw¿¯}Öرc+çÃe= ížãû:¤­0Ç+'k½‹12gÅw­P”K³Ïiw·µê¢óÍà>á9³FlÍ% «D dÖ¨ÙÝ“¬0'0Oõc?Î6Ûl™dÖØÓ]ËœÅÏ©ó®0§ ÈÀ|Þáѹ:—ÞxøåS\“5´kþ˜µŠb„’¸ÃD(Ešn¸aåw»²Ý „yçÍ#kéçDaýùÜHaŽÓ¹çžÛ)ñaÍdW™8#œ˜1`ùv ¨ßá‡Ù)„ìjùÄz¨ÔÍ—…Áa†¸döBlÿ;Gî»B¦*M}é^^1Ò ·ÇžJ³/£¸æþåžC¸^$Äý÷2Šš²C»ò ËMß*:B¡B¯ÖgúZ]0Áhˆ>0 ­R˜Ã(òelBQ€{^þ0šb¼ôJêЕT«Æê+Ìééû)#cÊ]¯œæœÿ£œ(\k¹l¶®¾úÓŸ&v…ŒÏQN2†!P¤ïg|Ç3Æ|Æ/Xúw¼ò×-»O'<ÆÏ Æ]í íꓲ*ÌËhß÷}?÷%÷,c6†Ž¸çµžeª¶p@ñÉȇ¼÷ Š@æ¥a?äŸ /1| •èþ·ýöÛ¯é9QÑ:æ™ååÁsgWŠ;# _WÄÇ®žKUx±¥®óý¼›~™~ÑÏ[}û´âˆÑlüÎ,}bZ@)î뙫¦¹œ§~üF|¶PJ ”õ,tbŽï9q¿„LxÇBx„‘bXí±ÇΈ%ŒÇóÏÙ}šepiö9e,VèR˜wG;¨ÿ#+`ÙÂ*Ö3–`(V/`@åI0> ¼'¤ è1@ª0ÔC>ö¯þ3ó"Œ`1Ì­5g¯—v»æõÊPä·nl¯Zõa^J»ñÞeWþW¢YïEî}È·)Gî9Ú=oèõöÌ[_Å R˜F;ת% Ãþ‘Eƒiï\ñõ, ¯cQ¥lS‚ÑYø;Ÿ½n Yc½ÿr>/Ze•­}z:Š@³¤0o–\\—UaŽƒ—V|„Bp: ”G+¯¼²Sö 0EYÊˉuYµÊÁ +ÍT¢HeïU„¥pæ°šÏwhY‰â³Je|ϼl°"‰}·Yˆð‹¢8.v(´'”èa¼Xa—#Œ›¦0÷ñY=ÆeZaU׺5Vž„J›0rÖ|ý¾…ìbÝ Vå_OaŽÂŸß}y±À¦ãÀ}ÃJ(„r>.Êïpÿ^2ؘö &ˆÏÀÆŠEX `EPKûn´ÑF•ôˆ‡q†BoèV…9ÞP¤ýp Šž¯P•Â¼öý ±§už€"–>>ƺQri«æîø~ʺõ’/B ¬S‰ƒ`+­Gâ>Ÿ¼C­Ë{ײÒκO¬›â*…#ñsÓÊI¹‹Ö•}!½GöWŒûQv«’ OÊCžf’u¼ò¼‹–ݧ™[PFÿ‡¡F;Cš€¬}RV…y™íËÊi戰E¹‚ÕwlÃ^Ýa»cŒXÉ™õ^¡=y6âyéòrÀ›]ÌO¼±ù1oå|Þ9Qulf>–•‡¿—Ù꤫Üçð /©Èà bCÖzוñÆV”1üÃð&ô7H{-6ØEáŸ6§æñÆÖÅjœ¬û^ֳߋiå‰ûû¢s|_¡Xa'ÆX<‡±ÿ*ïw(j0b‰•A(ÔãçtËàÒìsÊ;ƒBw¼;ÚA¥øX‹Pž¹p8ŽðYOìÍð©$nqâ1—½ZÄ}$q)ÌI׺ïv^ãrøïÌM[!›‹åTa¹âÏíš?Æù–õ½[Û+®Fó³Z/7´÷óÖ00—òmÉ‘ûÆn-FÉô¹×Û3S%iàHa>pM^Ua¼“…ý#^wÑí4 ±±Û[lQ¹Än[X•¦O-‹8ñ¬ÆÆÕX±Îw亱üª’¸>ˆ@R˜ç€ÕkQ³*ÌÃzaeë;$ŽtBvÿêU˜H²"8ŒKçh÷ªrµé¯¡Ó ãbÕ›Pœ†ñøÌ$KÏpòÊgÒ\É®>ãór+p’†qê)ÌY¥Æ-KaΪø0]8Äy³:#-ä¢ò2ÉŠº0ÿz óðÀòËî˜V wÎîâÜå‡i³òez°ÜŽ]CòBŠEV²„•:az(äyÁPè~ݪ0GxÌÊÝ´?*<ç^°Î½'…yí{Íî5^õ|"ÏPÈ`”€rõÆoLµ>m…Âá”7† }Óú_êÀö$(X¥‡VŒ#±…²zê© Ê5o™Ë…݈#†¼0ŽÆ‚¼¢uŸWHñ\ÔrÙKÒ7ì«Ùz#yÆ«¢eóöß1Þ Ë‰’(w|ÜVÓd­è“²(ÌËl_/¨¦.ðÅ2MùS–aÐÄŠõ<÷ i¦Í¹Q xnî»ï>·]G/¤Î3'*»ŽyòÎ˃{%iÈïOÌÓj…í·ßÞÅgNØîy þÐà’rã5îs0rðãó¥—^ê¶ÌëÈçPÈâëê놱D<'%N™ÏB'çø±ÂA>ïMxˆBMÿ¼Â¸1ï2¹³Ïi\v}o?)ÌÛÏ\9Ö'+`‰œÂ»ÒöccÆõ×_Ÿšc7Âbµžþ|hVaÎØÎ;+会/‹?ÒßòŽÃ8E™@™Ú5ôõ/ûØ­íדw,Ú6e ÍâÀ»óVß–YEYkÎ_ï¿÷z{úzè(!)ÌCƒ÷™w³°oäsì^=¦Â˜Û,`ò!öHšxkAÏÃ"η¬ÎùÆÀ¸a§?ËÀ‰ "P”€æE vñõÍ(ÌYÉv6µV@Pm&—a\\¢#hI *É&«Ó,ì…i2q¥3L t´Aã•Ë±à —óašõæ¬Âã–¥0gE›O÷µiJè¸îK/½tZµ“¼BTÁ%ªÏŸc-…9/pá>‘¬ö Ò [€!½ø⋇Deó° µV3aœ¯’òð!‰êDWèV…9²ÕV[mÈ.h–0 û')ÌÓo+úÜ°àyFž%àÄ+懪ðúV(ÌÉ+`­²Ê*©ã ã÷^5âЊq$V˜cÐQK¹…[eVç‡}(Ÿ;¢­ë5×\SQN-±Ä®<(ÓþÖZk­ªò \ǽ}òŒWEËæ~f^rcÎP‹sx]YŸÓd­è“²(ÌËl_Œe¼'ž/¼Õ (,$óK_‹5ºwê¯És¯p ÷KØ®|¦~a Ïb®É1 YçDeב2dÍ;/ÒFhå•\ð`!kZÀ`Á¯Àg¯ïvÚ?vãG™1 ƒ÷üÁŠ\ ¢Æ@7l{Œ;14òþÊI±Ï]Z(óYèä?V˜Ç,ºÃ<ž‹ÇWÊäBÞEžÓ°ìúÜ~¾/i§Yûk©{‰@š6ÍXŒññ%m‹<áxÙQ¼EO³ s2ÏÀŒmiüv á8å?#bË<¶7jÚ5lTŽfïæöòuâÁK$íC»0fÅ8loâÛ#óYÞãò„^oÏZ«Ì="›$ …y“àzá²V+ÌcB#…yÜ1âŽ;i ó8Nü=îYyºËÙ‰ætâcÇŽu+Ë™,û€+§;ï¼3aŸX¯¬ó=Š£´ÐŒ5«€võÕW¯hÒVŠ§•)Þ»Ëê8äQ˜ÇnUhC…î'Э s¶ hÐc„Ÿæé´b×ÖôUižBâ«™,£üÆc^Aê…V(ÌÉÏ»çõý+ T3¸ =~0v¤4µb‰æ(¦ëEm´QU͸‡"uÅ}±gÄÞR0Êó[篊”=æ~ &¨_;Ç”4Y+ú¤, ó2Û7\AÕÈØ÷Ï÷qZÈ{¯¤)ⲺÇÌ:'*»ŽÔ;kÞyyx¦¸õ«ç¸×ÓB!„·Ùf›¹g~Ç+¨ýoí:²*<6Bï·úÝü…^‰X!èû)ă‰¯Çšk®é~Çð4mµõ+óYèä?¯Âœ}ý<3Žñ Ë2¹À¹ÈsÊõ #àµúìΕL9*Z XŒÅðŠöm|æ\X…æ=”œ|òÉáOîs sB9À;Æ[±|',#ï<±gœ°Píš?†y–ù¹Úkë­·v÷ †ŸõŒ.?þøãÊ–U¾ 'tÒT#ëZ {½=kÕK盀æƒÝþÔÎÁ<ÄH 9‹Q€ó¾¹è¢‹º÷>ÞM}?Ê‘ïcÆŒ©€ŒÇM Ýúïx_tÞD )Ì‹Ðëòk[­0÷šn¤0!tŒ ®qhFa»·$ípO¾V(:(w³ÂL®¥CÇ +PàÏ:ë¬Cöï„·úáàUÏÒ–zøpÆgT]‡%vÏŸGa“°íTnø:队@/+Ì©-ÊRìR˜§·ý³Ï>[õ\¢ØhdYÏÊ;ß÷³Q£U¨>.ÏY+Ì© ®ãcCò@‰¿üòË'¬NŒ÷T)´bÉ«0§<§œrÊ6°ˆÓl]ñ *ÚØŠÕöyþX†¼ãd³eóLûì±Ê¹]¡YåËÓ'5R˜—پʄ«öq·^4ä½WŠ(â²(­[QGeÉ›xyyp r¯ºêªUý‚†PéÅsŠënúÀv{¥Nͱ›SÊ„&c }3ßYYÎ)Y Eè§qÙÎÎu‡zhjÕÊ|Ò2hç?¯Â<æ*Ì[Á¥ÈsšÆVçÚG@ óö±VNÙÔRÀrõ=÷Ü3d…c«Ï}Øj«­ÜØÀ–,dˆCY sŸ.F|xÔßs›Â¿X ¦¢¶]óG_Þ²ÝÞ^x;òµx@y^ïÏ[aÛñC߬¡×Û3k=o°Ha>Xí]«¶xDÿ„½PžD?‰G3þ³âzÝËŒ}ÊV´¡ŒÐ{‚ñ¿Çk•Áñþ:ÞD )Ì‹ÐëòkEaï;Nºûl…¢ƒ¦oF˜É¾Š ¸pš}öÙÝ —ƒ:È­2G)á;wŽíV˜#œô.©|9²º1aõ’¿ÆÃU›ð’ ýüä'ë¾Ö­ Qäe”ò `ßb‹-  Å°üñꫯ.”fÚÅíÊÇçýâ‹/VÕ‹-3B%ŒكȻqÇÕ+.Žëý±·³g†µi—½ÏÓ¶òó«õ™r²º=6Æñy±ø¦›nš<ùä“©I´biFaŽû\_fŒýÍÖõ­·ÞªJûˆ#ŽHe‘çdÞq²Ù²7*Sl Ö+ sꕵOj¤0/³}ÙVÁßQÐ yï•"Š¸,JëVÔFYò&^^\ãCÜ·0· ½{à:vcú÷ßß_Ö‘cÚjqÜŠãJׯdˆînÃ{ÏìWÎè|f|ÂÈ+-”ù,„éwbŽ_¦Â¼\Š<§![}n?)ÌÛÏ\9Ö'PO‹7odŽ ;K¹„WZãÙ/Íà·l…¹¯ {¼²’|–Yf2n1Vñ>—ºá6­\YÏu{{üñUíAŸWï/¼¯üg”èáBzlz½=ëÕM¿ .)Ì·íãš3óž{óÍ7',¨c¬eÆ™gžé¶¿dÁ%[´ùí¶|?zÚi§U%{ŒalÏN<ñĪ>cjú]h–€æÍ’ëëEaÎjßÙrÄ¢)ì[¡è ùó 3)®gši&§@µ.ûåbÅ*ma=:¡0gµeX†¬V³±·Òx÷Ýw«ž)Ì«pôå—~P˜ãBï•W^)Ô>íRd·+ƒg:ìø+k}\Ä8È_ƒ2¼Ñ‚#ŸcŸþ wŠÍÜõÒW!<ó‚à0/&ÕK.¹drã7É¢ãH¬Ôjä’BÅåÀ wCº™ºr߇<0 (òŽ“ä×LÙ•Å`X7ïò¹Ñueü^T@–µOj¤0/³}ã´ð’S4ä½WŠ(â²(­[QGeÉ›xyyp¸]|ñÅ«îùÐ Àk¬á~Ûn»íR•>v™û¢ ŸOŒ¬X¡À9>§2adê±üµ¬Ä•ïÌGÂí™ÂºÄm[F_ש9~™ óVp)òœ†m¦Ïí'àçI #Û_2å8¨ê)`a‚q²ü…&žG?üp÷+‰1N yæ¼ÿ @•%°Úü7¿ùÍñŽrâ~6-´kþ˜–w纩½âú0OòÆ´¼ûaœšåo©¥–r{ì±qò©ß{½=S+¥“O@ ó¿†@·ç`º°ýŸý\¶~|æˆq4»aØe—]ªâÔÒ‹„×ð9MÿÕHV§¡ï"Â<¤ÑgŸÓ:ŒØz'®òÎ;ï\Õ9ýüç?£T¾ÇJÒN¹dÿàƒªÊ<ýôÓW cC'ö0àöWôûu œ{饗*P;­0§ ñK{šg ñêx^F’…A óF~î…yÜ2(ï˜ìÅ÷s/üÞ.Ev»òñuCù+´QæÕ ¡Â<œ7û™}æ‹V”°àòË/Òßù2Í7ß|U.ɯãH3 ó¸¯gžyjâÈ[WÆ PÅXŠ‹Þ"¡Y¥_Þ²×+#/m¡ûpÚ™ñ·]¡¨€,.g­>©‘¼ÌöÓÂØ„ü‹„¼÷JE\¥u+êŸ,y//® C¸ÿ7÷<[\°â¡njyÖ™›vCðBu߇Gö»KÛ›žs±Q@x]=vܶEûºNÎñËT˜—Í…{«ÈsÚ ÷æ —A óAný+j˜"”OÛ~ á»_Ýýƒü ÕДçQ˜ã©hþùçwû”g¥…ËÙáÇWÉ­üøÌÜ.íš?Æù–õ½›Ú+®ÆÞm02SŒÂ³ü]wÝuCÚC=î½F¡×Û³Qýôû`Â|0Û½™Z³¥:‘ð} o”^™îÓ<ÿüó«âdÝ.“ňaÚ“M6YÍñÞ祣Ô# …y=:=þÛ (Ìã}uÙó" ­Pt~Va&à +¬Pé¼Y“&¬GPvðµ,©²æ2È* Ýa‡ªÊÀª¼pßÈ0Íð3ÓaÙyŒƒæ1‘þûÞ ó«®º*¡OÁvÖÐ.Ev»òñõF‰é÷zóÏûèÑ£ýÏ©G\î±Ç™ÿ|ºQÂÅײ.o`Žr:´0Åeû žp ÎëG˜/Ÿqÿ†VŒ#Í(ÌYÍ–uóÍ7‹é^8š­+œÂýùP¨Ýzë­Ué×ûòÌ3Ï$ì…%±yÆ«2ÚÉçÃBf|ÆЮ]¡lY­>©‘¼ÌöÅa†f¨âzÊ)§dFŠ{ð‡~¸*~ž{… ‹(â²Ì‰ZQGÊ%oâååÁ5a?~ü­ppc~Î9ç¸vC©@?Ø ½gãgÔ?餓j#`/<"¯µ‚ÄÊ|:=Ç/Sa^&ßhEžSŸ†Ž! …yg¸+×Ú¼¶Þ60gŸ}öqwæ´Œ õ Åò(̽ìí³÷:óòZ'Œñuôç¬ä«Êz:=Ç/Sa¯²¸xöEžSŸ†Ž! …yg¸+×Ú~ô£¹þþ{ßû^ÍHï½÷^2óÌ3'VZi¥º.Ôó(ÌÙ‡•4‘ñ sËðœŽ[µ¶Wj×ü1OÙóÄí¦ö Ë}ï½÷ºùm€'oÀgØ~|FÇxW/ôz{Ö«›~\R˜nÛç©9FEá <ï¢ÇIÓ‹°ÕÉsÌQÕÏ^rÉ% ³‹W¦³®‚! …yz]~-R<™;ùä“ë–º]²ãÞÜ× â±cÇVÕñ‰'ž¨üN<†i31öiq¬çþ#^ƒB&- <Ó ÷‘ ãÇB/„ši!k¾áµ±ßZÖV¯¿þzÕ@F¹7Þxã0©ÔÏÔÉ× ñ8Haé¿ïÝ 0O[Mºì²Ëæ†MqÌ1ǸÕ¬t7n\æ4p럼òÊ+3_Ÿ5b»ò ËÊl_'Ž_|qøsáÏ~ßZÒÆ…p•¤·÷Þ{§&‡òô±Ç«êûèûÃq¢ãH^…9åYsÍ5+üQ0…Êi*W´®ñ€}¥˜7„,bˆ(ËwÝuW·/ü‘GY7ÏxU´ìq¹üwö?ïY¢i¾ã駟vãW­½Ó®kt®]}R…y™í{Øa‡UqÅÀŽÕD«k¬È×Zk-'¨|衇ª¢å¹W¸°ˆ".뜨ì:Rî¬yçåAÚq`>ìÝІϊhæ{õB«ž‡ZyxàU÷åeKzÆ-¬V@ÖÏõܱûüËz:=ÇßðbU/¬¿þúU¼®¸âŠªèeqñ‰yN}:v†€æá®\kXo½õ\ÿµÆWÄc·#®½öÚ8jÕ÷Pžá¯yþùç«âø/ÌYy?$+ŽóxÀšqÆ«úᥗ^Ú'[ul×ü±Uã}7µ—Ëû̆nèøcìÐÈSš¿.<âI+ö¸Fy×]w…ц|nW{ÉX'D …¤0o!Ü>I¯Ž¡a4+Æ8à€º[ÿÅãø*«¬Ò²>?vsdë (B@ ó"ôºüÚxµ0Æ¡‡Z·Ô±Kîz{˜#ì ;¤Z+¢}†áÊA®C0ïaš`YQU+¼úê« «Àý5¸ïûï¼óNåwâᎠAd˜üÆ‚$,Ÿ°pJ ”ßçËqÊ)§¬rÉ…ˆ½rüãWÅcV¼Ïn>úèªx¸ëJ Yó ¯ehXVÊLÆJ8ø"«€ó›ß¬¤¿Í6Û¤ZØÆíÏÀY+„*åŽëµ®ÓùÎè…9Ïqx¯óy™e–Ɇç÷ÂÞeîöÌg Lã2à…¡ìЮ|ÂrÇÊÇí¶Û.ü¹ðçV*̱Teë‹´À¸á;´ÝB -T­ãH^…9ìQäS>Æ&öaƒW:7[WV¿¢L ï_{¬F}ÿý÷ãìÜ°o»í¶nücuyèŽÈyÆ«¢eR¸ÿž¸ð «êÃ÷8`ä…"Ø T¯%$¯mô½]}R|"ÈC™í˼`ºé¦«bËý Gò WøÒ§þö·¿u^(×öÛoŸÄF yîêÅõá}Êg„‘YBÖ9QÙu¤lYóÎË#­Þôk'žxâNÞÔSD·òyH+'ç¸!@ Û4­‹¯ûQÒH3ÚŒ¯+ëYèôŸº†Ìš­¾úêUñÙë> eqñiyN}:v†€æá®\kð0XüPo ‹eô‘(µcùKœFZaÊg¼_ð´…L¯VhG{ÖÊ[çE U¤0oÙþH÷öÛoO–[n¹ÊØŠ ex,3Šk‹ž'4LÂK='t6á=>çÙn#Î_ßER˜÷ñ}€ò8œÄñyƒ 6¨[ãزö¸ãŽ«Ÿ½MÃôQ¬Ö{y™zê©«âÇ®dÉ(V˜“þᇞ:™å¥$,/î¹ÒöÀ L±PwÉ%—Lp£HGMÇ{ÑE%¸žMsíˆâì7ÞH>þøã*¬Ü ëÏË’î!´eÕ –Pñª‰]vÙ%Á•×[ÖU,{`a¨[#T¾ÿþû‹poЬù†nt¯»îºª²Ök+öAAÖ ERÚª1&Vú¸¸£¼qàÅ"Tª?Þ¿Ô_ƒ¡AhAÜÛn»Íÿ¬cè…9ÖÝþ~ôG 0ê½Àz¤<ãx™Øwß}“oûÛ•t:è %Ó1\ìË@\vhW>a¹Qjâ¡Â× ¶<ße…V*Ì1–ªç†˜ýÀ}½öÚk¯ª*µb‰=x ûí°¸¦ú»ï¾{ªàÏ+›­+‚#Œž<d E„mÜ]~úé e@ÁÌ }vš[­<ãUѲ‡¼ÂÏ¡„dŒ»qØsÏ=‚¯/ŠVBã>±hhWŸï÷•¶'f™í‹^8<3dî‚Äý÷ßß½o¹å–n{ æ?ŒiFxyîÚ„9‰ÏÓ³®ðÊ:'*»Ž”;kÞyyvZ`N»µûå/™µr®•ÏC%“èŠÕpî‰$mÞ]æúÁp=÷WxYφÈþþãØî9>ûñ†ùÓ÷×ë·X™Æ £ËââÛ©ÈsêÓб3¤0ï wåšN€y°WtÒÏâªV`쎽e0o­˜§¹r¯çI Ù‘ïO™ûlµÕVu-1³b…ÍGáÜKã}ƒU¦Ùã•{qŸ}öq 2¶qÀÊÈ,!5ýk|=eàÆȈç§hhW>µÊyî¹çV3!eÙ²B+æ´†´{<ö<øàƒÉôÓOïê…Eê‹/¾8¤Je#¼`†cÂ6Œ§è ø¡Üå¾a,f¼£od\á|ZðJç"uňŒþœ4Â?°¬ê™Õ®$g®à—(Ìy)ISÒä¯Ê({Ì£.\ûz°>Íx&TÔù¸´Gš7š8ZßÛÙ'ÁC_vd_ÍxL.³}YÕrø|9bDH_ˆ±¤W¼0×Â0. óÜ+´küMž0H›ß†m”wNTfóä‡GX¿´ÏŒ}¾mèçêynâúV<iåŠÏ±ýƒ/'«·Òî“ø¾‡÷>ÛBd e< ô×a?NùÛ5Çç‰Ý’?ýq;”ëôמ1ÇUW]uÈ Œ2¸ÐEžÓ¬m¨x­#àûí´1³u¹*e¨&€¬à¹çž²¢ol—”&K ú1ï1 aõô(²âÇ}9}$«QÎ3'C, £%þ©§žê<,‘.åCy|à 7$ë®»ne>DÚÈ‚¨[è¿ÛõN[öxß­íÅÜÅ,^vÿÅ[lÈø·EÚwî…ð]˜´ü²îË0´³=Ã|õYÚA@ óvPî<±5ÊéB ²%ö!OóXX«v,DäÇfd3è50ßs•±=.ý0ò*Þ{ky•¬•—΋@)ÌÓ¨ôè¹;ï¼Ó)5™Œ/¼ð®³ð“·ðˆ2ë„Q(wrÈ!Nh‚€3Œ‹›ñÍ6ÛÌu:tLûè€P ‡ ¿2ÊM„o¼ÑYø†JE8+þ¼Í4…ù<óÌãV~“/G¸Ëâ3{«¢<`U «Z/L”c€Ð Ø—Áê⊋¥p5:ud•+íyñŠÃYg5Ä…$95«ÚÆŒ㘡ààœÏ/<¢pFƒ‚&v O<R¬ê C–|Qò±º¯i < PΤ­¸D9;Pâ^`ÂK _5Æ=±Â +¸ti,ª1X@xΑ÷cXg>£pA‰éë†Ûuîظ´÷++º—@§æ¬À 0Æ/á‹pxÏq£ìCh‚ò7zùŽB‡¾.íEðï·Ï÷'ýjè (ÌŸ´™(¢øäyAp7´+ŸFåb¢>§ñ¨®¯÷{8VÀ¾Œ*biÚq«×sÎ9Ç­‚Å;¿±Êï#iâ²Ç̸Kö.ÉŸ~Œs¬‚ðFU¼(ÐgžvÚi©žT<§2êÊXŠúù´g"¼¯1¬Â³ŠÃ}9Âc–ñŠøe”=Ì—ÏÔÃ×±9bùø¬–ëå?Ç«/}üFÇvõI/½ôR‚ öqN›“ѱ¯8ã¬wKVvû2w¡ ^0íÙ…Gæ ̉èÃêÍÕÝ+x°AàÉ\)6ð$?úxæ<Ì}xŽÃPdNT´ŽÍæ݈sÌ,áÑG­Üß«6 e?òó¿ãÍÉßG¸ðËÖqñ¬£dÈÊxx/êÄÿŒ3ÎpãXøÎâŸ9Œˆl·ƒò+#y?d~íÇ9#cc Ê"ŠráúfŸS_;OÀ¿ÿ¥Í‡:_:•`0çÅ(%4}UØwqz¹ýaexCx» …ë>.ódQùm¸Â<øÌÜ¥2óŽxkCãÄaŽŽ\Å?3,¶ÀébÈÍ\ž÷&/ôçÈâ "Äåj×üÑ3(s¼ïÖö9r¤{ÿf1Kؾ´ïîŒá̧ä”Ì¡¸¯O†iùÏÈR¹/‘qñÞØîölTý.e¼l¢½—2-”ä¼KðŽL؇¼“°(‘wÑFFíi5g‘ïÃþ}Æf裓ékýBŒÂ1œ7n\ZR:'¹ ã ;À+ô«p4Vn¬ÒCˆ†5²/ƾ„»JÌX«c'©×Y…­±Ê$c…®ÆNö]éâÚ‘Ô<¬[sc_ŒU¬»ŠÙXA¡±‚ðÔ¸¤mÆ.®U꫘2Öuw%®~»òÏX…Œ±û‰;ñ4œ³¯±‚`cdƺ=wŸíµr]ÚkÁk¬ßÀÉv¼Æ®|0VÀll‡k¬°ÈØ—c…­ÆvðÆv¶Æ¾ä;á5¶svñì$ÛÄyXÅ‘±)c_¸Œ]eiìÀ`¬òÃX£³ñÆ;^”źŠ7vå´±@cW+|pyØÕã..ù§U0;Ö]»±ƒ±/_Æ:ƺžwåðõÊ’¯u-m¬»wc…yÆZÂúK«ŽV¹h¬RÊؾªóþ ¼áe@c…Æ®JrÜh+Ú Vð·.î]]ïÚÆ_ËÑî…èîIÊàe_PUÚk¸áî;à¦Eul­%°±/v©¿ëdç Xa¬±†%Æî‡f¬û¶ˆgÐNÂŒ:”ž§U®»’±nºÜ»×^{­©Õ'Æsßo½õÖfå•WŽªû½]ùÔ-Ä´+ØÌn»íæÆ +l0Ö‹Äç?K:qX[ã,wš>¶-èo­ò×Ý“Œ{Ö´±«Fݸdû´9c /\f•6©Ù–=ŽÐ§Z!±/›ÆîîÊÆXÌXhjn챫âõ†b¬rÚXezÕ²¬º2‡€“U´¸±×*²Ü8Æ3Æ3Ác'ý?ó+ÈŒ‹Rùže¼"rYe¯dl?XÏÆE¸Svu¹±–͆{ V!ê~³{Kº1Žv&XÏ2Æn§Goø½]}ãòˆ#Œ}uüÒ ÆsÄ<ÏþUÚ©Ìö%O»rËXÃEóä“Oºû†{ÇZ˜»ù]Uîîú;æmV±™VLw®Ñ½b ZŒU†»ç£VOú<Ï€÷æèÖhÓµcø{­Ï¼÷X##ק[„›/ÖŠŸ/ãYèÄßîyëæZŒai1Ì Œ]}ïæÖÌjͯyf¸—~úÓŸV’*Â…v´Â±¦žÓJô¡ã¸‡x¶hÏzývÇ ªô-æRÈFèjäBV¡íæ{qÆ;Ò@&eœñÏNþ…¬Š{¼Q ë½ÑX…@%ªu¿íä=v¥¹±FJNNÂ{0sIæ‘|ð› qó0æó”¹2 úèX¶Ô®ù£¯D™ã}·¶òQÆÀ´ûˆvežl¯ëAËcI=ò~f4•~15ÒOò®a¢,®“2ŠzeÔo"PäôÁÖHÈXÃô2’T=FÀ.Âsr,» “±+»Ýû?ratÈ×ÐÝ j6 c<ç}Ö‹»?ÆWÆUæªèpȇ±u¡…ªÒ›4›§®HaÞG÷S:©<Á+épº(ÃdÕTú4ô#$EÀä²Q .×Ä s^"x‰ù£UFÓùRG&¶CQâ£ð¦£Ì¬['ØEKºL©—]©T¢[·[.M:u”ùì(izA-n؆Ö%—«üPVû¼©;…ʘq¥ôlVŸVÇFùÂ2K»Âew­`]H;f”8Â9^`gW溗?€i!Ë=‰Ñu´«ß\§¥ãÏ¡”áeS¡; tJaÎs]Ë(£()žÓF<žWž<‰†'yB»òÉR&žWŒW0b\°n–¢9˵õâX‹ÐŠPŸþYÑ€€%<ý9}4}#÷ †\ô¹ôAô±G5jkÊRö8Bùì m×_S6ÔüQúYßïÅcJ—²ëJy{)ÌHŸöæñ+4pK+?×h¼"^Ùeg®b·S1ÜS(j1 «¥`Ĩ …( JæÖ3ÐÃè ü¼¡]}R–1–²3Îó,q CYíKšÌhgÒäŽc}Ü(°*Ýîehð4ƒkÉŸØ­hD — Ø=EÝOÚYü#ÔÂ3SÖ ç!+)Åþ# …yÿµ©j$µh¼¯EFçE@ê¼ý&"Ðˤ0ïåÖëòKaÞ‡ª* )̦©+Å}Þå—_îö+EÃ~mìÏ® "pË-·¸û·‰ìÉË>æY”„ì¿}ôÑG»½¸wÛm7süñÇgÞC¹SuU¾"à à*”?”\>°8^@؈=¥Qžg z²’R<èOR˜÷g»ªV"ÐxÑw¬¤0ÏJJñD@z€æ½Öb}^^öè ÷¹ÀµûUÈÕFŸ7¼ª×¤0ï‹fÌ] .»ì2ÃJ^ö.b5ã;ìPÓ=aî td$pýõ×›ãŽ;ÎŒ3Æ­*GY>à 34¼š=“¿ÿýï»}Ëñ’€Ñû`)ˆ@/¸÷Þ{Gö´gÎyæ™Ç{°ÁC=äöu{ðÁÝù,õÑó…’âˆ@¼¿ÛWµh¼×} "P„€æEèéZn& …y7·Î–U0³Í6[UÍÇo¦šjªªsú""Ð}¤0ï¾6iW‰>úè#sã7šc=Ö|õ«_5Ûn»­9ì°Ã´§y»@ù˜³Ï>Û\pÁNøwøᇛ 7Üй¡Î‚üC9Ĭ´ÒJf¹å–3SO=u–ËGº‚Àª«®jyäg`ÊÖßøÆ7\ßûöÛo»U秞zª3 Éj|ªç¡+šU…Ž¼£ø•¹´…€Æû¶`V&"з¤0ïÛ¦UÅD`à Ha>ð·@w@ؽûî»WŠ•‹ì)ª "Ðݤ0ïîöiuéXÝø裚óÎ;Ï­ð}ꩧÌä“OÞêl•¾˜$IÌ’K.é<ì±Çf™e–ÉíN}ìرn%îÄO,¢"ÐSð¢ðÞ{稜yµÕV3W_}µ™fšiR¯uRÏC-2:/ƒA@ óÁhgÕR4Þëh–€æÍ’Óu" ÝN@ óno¡(ß¿ÿýo§`yýõ×ÍÝwßmÞxãªZç;ß1üfŸ}v3ß|ó™õÖ[¯êw}èR˜wG;t²ì¡ûÚk¯™qãÆ™•W^ÙL4ÑD,Žò £Fr oÜQg]I;@xTÕ>&°ÝvÛ™‘#G©áúë¯ï¼~06+ˆ€ˆ@R˜ç¡¥¸" " "0x¤0¼6WE`PHa>(-ÝÅõÄÔ–[niØ—ŠiUŠü-±ÄÎÍoZè,)Ì;Ë_¹‹€ˆ€ Œ”î¸ãó»ßýμùæ›ÎÀ”ñx£62óÏ?¿6lØàAQE@ ¼>]," " }O@ ó¾obUP–€æÛôÝSñÿüç?†6K˜bŠ)ÌÜsÏ%ªâˆ€´™€æm®ìD@D@DÀÀè·ìü±ÛŽ`ꩧ6ü)ˆ€ˆ@3¤0o†š®Á! …ùà´µj*ƒF@ óAkqÕWD@ZD@ óU²" " " " "Ð&R˜· ´²% …y6œŠ-"Ѐæ )‚ˆ€ˆ@R˜g¡¤8" " " " "н¤0ïÞ¶QÉD@D@D HaÞ ­ 2ˆ€´‚€æ­ ª4E@D` Ha>€®*‹€ˆ€ˆ€ˆ€ô)Ìûª9U(€æ¥#U‚" ]B@ ó.iCD@z€æ½Þ‚*¿ˆ€ˆ€ˆ€ˆÀ Â|ÐïÕ_D@D@ê¼>ý*"л¤0ïݶSÉE@D «œþùfܸqf¯½ö2ÓN;mW•M…hLàØc5_~ù¥9î¸ãÌ°aÃ_ " " " EÙ2À™fšÉì²Ë.UwUVD ¿ HaÞßí«Ú‰€ˆ@Û|øá‡N¸6ÕTS™‰&š¨mù*#rüå/q M7Ýtå$¨TD@D@D@úŠ†uÈ'žxbó­o}«¯ê¦Êˆ€ 6)Ì»ýU{XR˜lÓ«â" " " " " " " " " " " " " "0ؤ0ìöWíE@D@D@D@D@D@D@D@D@D@D@D@D@D`` Ha>°M¯Š‹€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆ€ˆÀ`Â|°Û_µ% …ùÀ6½*." " " " " " " " " " " " " ƒM ·Âüƒ>0_~ùå`SSíE@D@D@D@D@D@D@D@D@D@D@D@D@D@:J`â‰'6SO=u¡2äV˜ï¼óÎf̘1…2ÕÅ" " " " " " " " " " " " " " "P„ÀÜsÏm.ºè¢"I˜Ü óÅ[Ì<ûì³…2ÕÅ" " " " " " " " " " " " " " "P„ºëßÿþ÷E’ȯ0>|¸yçw eª‹E@D@D@D@D@D@D@D@D@D@D@D@D@D@D gœÑì¹çžE’ȯ0?~¼ù׿þU(S]," " " " " " " " " " " " " " Etdó"Öµ" " " " " " " " " " " " " " "Ð-rïaÞ-W9D@D@D@D@D@D@D@D@D@D@D@D@D@D@D )Ì‹ÐÓµ" " " " " " " " " " " " " " =K@ óžm:\D@D@D@D@D@D@D@D@D@D@D@D@D@D )Ì‹ÐÓµ" " " " " " " " " " " " " " =K@ óžm:\D@D@D@D@D@D@D@D@D@D@D@D@D@D )Ì‹ÐÓµ" " " " " " " " " " " " " " =K@ óžm:\D@D@D@D@D@D@D@D@D@D@D@D@D@D )Ì‹ÐÓµ" " " " " " " " " " " " " " =K@ óžm:\D@D@D@D@D@D@D@D@D@D@D@D@D@D )Ì‹ÐÓµ" " " " " " " " " " " " " " =K@ óžm:\D@D@D@D@D@D@D@D@D@D@D@D@D@D )Ì‹ÐÓµ" " §Ÿ~ºy÷ÝwÍAd¦Ÿ~úÊy}è ‡rˆùòË/Íi§f† Ö…V)E@D@D@ÚF`ìرæÌ3Ï4³Ì2‹ÙgŸ}Ú–¯2V¼Մ•¾ˆ€ W\Ѽð æ±Ç3óÍ7߀ÔZÕþ!€áëçŸnÆo&œpÂþ©˜j"" " "P çž{ά¼òÊfñÅ7÷Þ{o)i*èR˜wC+¨ " "Ð]tQ3zôh§4_pÁû Fª‚ˆ€ˆ€ˆ€ˆ€ ¯}íkNaÎ*s)Ì«íU[ÈBà™gžqÊò¥–ZÊ<ñÄY.Qè R˜÷D3©" "Ðý¤0ïþ6R E@D@D@D@D )ÌëÑÑo" " " R˜ëèWR˜÷k˪^" "ÐfR˜·¸²’ Ha^2P%'" " }F@ ó>kPU§eðØôñÇ›o}ë[-ËC —K@ óry–žÚ_|a^zé%óüóÏ»=ÄxÈ&tR3å”Sšo~ó›f®¹ærM4Q%履~ÚÜsÏ=fÇw4ÓL3Må¼ÿðþûï›'Ÿ|Ò¹LùÃþ`®ºê*ÿSßÇŽkÎ?ÿ|óÞ{ï\Fo³Í6©Œj€¿g÷Ö[o™¿þõ¯æÿø‡™|òÉ]{,´ÐBfµÕV3³Ì2K­$úê|Qž}C•1R˜ÿç?ÿ1Ÿ}öYæ˜`‚ \?švAž´è‹ÿïÿþÏüûßÿNKªð¹¯ýë&ìÛ›I±àÏþ³Ùn»íÌ°aÚI¢%×üéO2·Ýv›Ùu×]3»ú¤mxàóâ‹/š½÷Þ»P¹>øàóÆoÊñ—¿üÅpOÌ0à ΥØì³Ï^(í^¹˜z?úè£æ‘GqsŠ£>ºWŠÞuåd5묳šå—_¾ëʦ‰€ˆ€ˆ@^R˜ç%¦øýJ [ߥú•·ê%"Ð;¤0ÏÖVȱ;½þúëæµ×^3ÿú׿Ìl³Ífæ˜c§ÏAŸ7æÛo¿mÆŒãÒýç?ÿi¦šj*—î²Ë.k˜ÇõKhVø駟š$IšÆE‹šòÕ ~ø¡9r¤AyÞyçÕ‹šú[³õOML'3Â<3ªöEüüóÏÍ­·ÞjP|£,GÁ͆b†eâ‰'6_ùÊWÌW¿úU'äžvÚiÍ ,`æŸ~w.r …;ï¼Ó,²È"†NÂï+Ì%‚rÒ¥Sýä“OÚW¹ç´×^{™k®¹Æ)¹LöÝw_sÀd*ÊñO<Ñ)lÆofši&Çå Ê$¬…šqÄfÕUWÍ”n/G*³—ë­²§è”Âœ>鍊nJ/TÊÙ™gžÙ\vÙe)¿ƒ!Ì.»ì’ú[|òòË/7çž{®yöÙgãŸJù~ 'öƒj60fÐÑß_{íµfÉ%—l6©Ò®cÂzã7š /¼ÐA^Y[/®yðÁÍÕW_í –0${ùå—ë]Ró7®E¹IZô錌ƒL2É$΀ ¥'} ô~ Ìž{î9Ë-ó ^Ö07nœ»Ïî¾ûî~ªnÛêÂý¹òÊ+»¹Öæ›oîŒ9x¹R^% …y¯¶œÊ]&n|—*³~JKD@Š¼1=t0gœq†ùãÿhþö·¿¹?ä2(ɧ˜b 3ÝtÓ™vØÁl°Á™¸<üðÃæ‚ .0ï¼óN%Mñ0w#]ðm»í¶fÓM7m\À.ŽQDˆœëÇ?þq!…y#y,r4&Ñžõ:>do,Ø<õÔSëE­ú­Hý«Ò—¦HaÞ¶Ö]„âåì³Ïv«¿QhÓ¡òð¡G!>õÔS»ÕŒ(uX5ÈŠç 'œÐ­nfÅ9ŸY5ŽRࡇ2+¬°‚¹å–[ÌqÇç”î(zÕ˜t¨( %Ì9眎¯ï2Ë,c~÷»ßù¯5¯¾úªaõÆ @Gy¤[¡NÆox ùè£Üõ(^V\qE3jÔ¨Ì^ÍŒ»ü‡fyvyµT¼& tJaŽqÐoû[g]É3JÿžK,-1"»Äî»ïGqß±ú;í´ÓœâüŽ;î¨ê/‰Àóÿýïß|ç;ß1?ýéO qüqóÔSO9enj¢Mž¼ùæ›Í†nØäÕÆ^m²É&nœØyç † (§a{ýõ×;® m±ÅÎ,­\ô¯¼  Ü~â‰'\û2~1Öùþ6íºZç39æ§|gœÄ¢.óÎ;¯3*øÅ/~áV\cLŽÂ™û¥_. Ö_}ƒgæÓùÀ=}ï½÷ú¯:æ À}Š‘ãa‡æîËuÖYÇœ|òÉn¾–#E®! …y×4… ÒAÌïºé]ªƒ(”µˆ€ ! …ù$•èj/]rÉ%nÑXiÎ<óÌcÖXc §·AÞX+&ò´n¸Á-’ÄóðöÛooË£¼ýýïïä“È'Wî´ÓNn!‹.{)”!Ä  –Ì7+ ™,¾øâ5££ü>äC2)å™Wã­¯ÄBõo”‡~oL@ óÆŒÚãïÿ»¹ôÒK"˸ù&L?ýôÎ å{ßûžùö·¿í,†xx|³:k%\Œ³‚0(‘ÖZk-ç¦ey\yå•N‘îãšÂen€}€œê”,XÁ«-Ú K-Ü1h«ë®»Îì³Ï>•Õú8 ÐaÅb?‡fxö3A¯[§æ(béß00Â@qÀjs·ÝvsJ,&¡µöŽá§?¥e¹çž{ºtIëϳÎ:Ë,¼ðÂæßø†ûŽÒ‘¼Q@¢$‹Wº39eR›¶M}9Kô!(êQchã'ÓL„7Ûl³¸*™¿¯·ÞzæöÛowñ1¶¢>iåÈœ`ˆ(ºñæñ«_ýÊœsÎ9f•UVIí#á‚«på#àf*Tî6£0‡)/ ¿þõ¯²~6ë ‚%–XÂ)àiŒŸ(#«Ùi7Vš3fÎ8ãŒjÞ=—bHÂx‡Çîã^x¡R8)Ì+(šú[æ¼0Á•±ï_(ˆ€ˆ€ˆ@¯¼×ZLåmnz—jEý”¦ˆ€! …ymzÇ7gžyfÕ‚½Ú±“/î¿ÿþnq^­x¤yÒI'9å8ÞñÚˆIVª{™âˆ#œü‘4ðŠ‹<‚ô‚¼²ä€°…w³¯¤xµœl²ÉR“@ {d•Yó d¡õŒʪ–ò(N¶A:LÀ*yë.#±By6W¨ü­»îºÉ]wÝ•X7‰}à‡”Ò*v«¤I¬B$!®]AY¹–t¬â¦rÝ##± w.Ìþ Wâ »ÿmb]$Vi”X ®Ä*FVÛ*ßërݱµJ·Ä*Ò†\cv‰ «ˆsñ¬Có^Ü[V¹R· Í𬛠~ìißýîwÝýoF«÷­5T©ê éóì ðÜe²ÊìÄ®€®¤eW#'œ«è¯Ãþ•ÏsÏ=wBOÿѯ[÷<®o¶Þ?’çŸ>±ž,*}¹u^+«†ç­ëíJäËdWt7¼®ìä=±.Î;‘Oì¤=±FK‰U0ÖÌʺO¬+údõÕWwc£5«âjæ5¯­õÃÏþóÄNv+éXKßÔ>Ú-$ÖÊųûÇ'Ö“k·ZéöÚyî9k¼üñÜVaÞkUÉUÞ,ãY®S"ó|[5‰õJØÒÄZ{;Ö)QuJD@D@ºš€5þvó„4DW\…’tÓ»TIUR2" "P*» ÃÍÝ(ü\ìV­Ž]t“tÐAɈ#»5¡Ó Wôº/«ãh•àÉý÷ßÿ¿„‚O÷Ýw_%Mâ"7L“©Yo‚‰U’Wd=ÈÎìJ÷ ¥îýX–Ðz[Nü<×rË-—X…u²ÑFÕý ÛbÇw¬ Ênñ™Xï‰U€'ÖtÝ?ääÖ#jÝôø±¬ú7ÌH2Àu€B  |Ùc=*zÿ€n¼ñÆ J§,/©(f‰»ë®»V:EÒ±+ã†ÔÌî›QgÐæv•ab÷…wŠr^‚Ò˜ÚŸþô§*C©ZÁ®ÚK¬{æÄîkÜ”r®Vº8àï½÷NìêÖºÙçåY71ýØóºAaÄØøˆþƒ¡f‚õ(Qé3­'‰ºIXo•¸¾/_zé¥ë^ÿh÷ÚqÊb®9rdüsæïûí·ß²XWM‰µ„ÌœFí–"ÉÁœØùn2I0¨Ï®¹æšÄZ„&Öb39üðëê’WaN?Ž¢Þ· ÷©õÐ’ZÆ„­¶Úª—»·wjÜ^>ɽìypìg…yÖñ¬Œö$/^†¬{4÷Œa‚‚ˆ€ˆ€ô/hÌ"‹èµº©¼"…@·¼Ke)«âˆ€ˆ@'Ha>”:ò/”³ÈXæ›o>·E,"AwƒÊn˜Xo’Éb‹-V%“áš­·ÞzH¢¤i·}«ÄeŽFµ‹…ü¢?ÒÄ ?má_­ë;u¾,9 |½YHÊ}j=9;]ú ´?˜¡üæ:þê-Dg½«ºxèî{챺Ökf¦…eÕ¿Sí×oùJaÞá=ãŒ3œ"Á?”gŸ}v÷ç-šÝ×<±.d+¸u7;$ ”1a^ƒ¦0¤Á ëî¾²Ún¬R«È{=`ýf]V'v÷^¯ŠÊßFÝ¢0·{UõsLy6› áªq,ë”ÑaÿÊg¼Mä vŸm—« › ôSñªlʇ+®¸¢™$›¾+ZëÞÕç'?ùI¦‰:/¡RÝîK_Å5¯Âüg?ûYÕõð­0| Û‘•îÍÞ?õòéäoÖTUûYaÞîñŒ{÷ÐCu|±ç~R^" …y/µ–ÊZ6nz—*»nJOD@Ê" …ùP’,úÀÛ2+<+Ö2ÞØNÂXer½K«~³{v˜W^yÅŒ?Þ]gWÙþ&›l2cEÆ —umQuMø¥èõ¤e…ÙæùçŸ7Ö]‡±{„ÉÛ±bHâÎÍ1ÇÆvzî3åòŸ«.°_쾥ƾ\ëŽÝØÚýÁe‰%–ˆ£Öün•IÆZ’™7ß|ÓñµnŒ]¡f¬…¡²†fÛ‰¼¹÷n½õVCY”ß*×*YÛ==ŒµÖª|÷êñôqÒŽ\Çýdn×ÔæÜyî)Ú‹{Š6åÞ÷÷÷¶d\{PvXÎ=÷ÜÆ ÒŠ£s XE­=z´±«qÍ‚ .X0µæ/·Ö“æå—_®$`'‡•{ºr2ãëþÈØ¢.¶ÝëÆØÕë5¯´-×…ì„Ù<úè£á©šŸï¿ÿ~Cv\3N£¬+!³þúëë Ã\ýõƺ#2Vq^éÓ¸~³Í63vϤFIúþVélè¯ Ö5»±Æ\M¥i÷2ö%¬r­U˜×ì‹+‘þû1ðÈ#¬œ&k©Yù^ëm0|øðÊÏ«­¶š±®á+ß›ùwìúä“OÜXçÅýÌxéý5÷^Z`ìHëïü<Á_c]²WúzÆ3úR»JÚiôÉvÿ-c÷s÷ÑóÖµ^‚Ì7ì–3æü£ëÛéÇçœsÎÔzùtŠŒge•û̹"M5ÕTÆZ;w´_ôltF˜?ðn˃y‡‚ v¿K•%¢}þ{ç_5æÿÅðŸ1‘a(*ÄP*BER)I7]]¢ô+Ý„’(M7¥ÝHWD?™n"—èæ’BQ3B¥‹4"QÆÌd˜ûìÿz¯™çÌ:ëìsÎÞg¯}Î>ßïg½^ßïÞ眵×å³Ö^—çó<Ϫ›V›{¸¿°ŽG&óú׿>ÈúÝ°¿cmÏy½õÖ+•1‘Ƥ²­8ÿø¾FÈö¼ARüøÀ=û¬TVç•èƒ|0Žì ¥Ü²Ë.¥{!0÷xb×­½öÚAVSEÆ2÷®Poaî–Yfç-ÌÃx7î¸!ä[ÆAYÆÓŸþôÞ£ÈV‘Z@¾uÌ1ÇØÇÒ+òñTvÉüæ,ßÅ/›ÈëÔÎcóÍ7²78‰»îº+´IYÈRý¹è½ŸËyoš!>™7º òØ 7ÜÐ1î7 Óª“2.ägE˜Ï¨u½öI jãA‚5/Y“€°÷¨£Ž /i:NB˜Cfzwî»ßýnʳ„؆8eÑç-öÜ›ßüæ±d‹SêY™ ž?HR¾ßi§Âb:Å éó¤ç­6Ý·¾õ­ðÇ=Ó•W^Ù—„+u$@`AXHñ´ï!~‰G©‹ë7¾ñλN±(C¯ä¾L^òöàË›‰ÖŸEì¼FYÀwaѤ¼f˜p!öÈÛmUôQˆ/#Í«àiiÅW>ùÉO:ÈHú+u†ð¡Îô)&J¼…j ¹ãgíÞHòn¸Áù£ÜwÞ X¨Qn!^³óV†¡=èk|ïÏ·ïÊ yaÞŒ0g¥?ßqÇ7Œ-àžóœçÁÊ#æñ†÷€ñ<]@OœiɃl¼¦eøÅ»4‘å–[®$æø¯š,7Ûl³>¢›ùå /›éI'ä>øà^< K& “Î]»îºë€Rù3v}üãï%•¸¬½ü å>çœsâ¯Âý0Âüꫯc3ó segLöZÒîùϾ;è ƒF®Q&­ë@ýöÞ%f˜·™#êÙ8ÎÜí½¡¸ýöÛ/Ì“ñó“Îg9ËNyX °®y衇BñÞò–·ôµ[\fÝ ! „€è"Ì»Ô*Ë4˜Ö^*— l&M«Í½ëvdKÞÊÑy+T‡ò?øAù@(±%c Š°ìÏb%ß&²­²þ2 FÞØóÖ„eÉõ¾ÛvÛmÃ~¤÷…¿A†…’@þò/ÿÒ¡¤¬  "Ì[Y728ˆ×*98r~ã†!ÑÍŒ4} Ð¿IÃíÐKÆkô+®¸b߻͢¡Eá ﮽s1y?I~“.½…oï u+‹·¯Tï²¾W~{eœº¡ÉÜå]ÌÙ(7X¸¦„9Âl”©C9k=Ž‹ª,¤„9c&s8Ïò s’‘ÓqzÌW¬_Ê°hRW+#ua¢Ü„À9’žù9$^—‡uk uæ30&ä(»å_Óö@LA! „@×aÞõRùÚ@`{©\2 êß4­6öþh°Â{ôëÛ Ú^âï|g0’‰Itû y Õ)^ë7‘AZz“ÊÜØ_xKñ`ìcå´+ŠÆ(•)yA¡×ˆv0o1?`*¬B`ŽaÞ¼ñÎ=÷Ü>ù…qÊ1ÚØÃC¶*)1ŸÀsÞ›nœlçï'•Ö©ÊZÞ‹aO†ñÏ°€ŒÕ{Ü-¼5zá³ |F•qÛÄ÷Èw1òCo’0úOR®ÅòŒóµ4Åñ‹Äýî»ïÞziêæûî»o_¯¸âŠò¥B÷2²›‡ 7­¾ÌiÀ2mSâ`qž†&Ï{7÷…?{6àÞµy¯äUF˜[ÞeÖ¢ÞíºýÜweQÌäcuäš’¼ñX7o¼ñÆ!>‰Ï|æ3…w±G)È+®7iB"@Å!g;a¹× ¿4LŠ'„;x[úÞ•n ƒÒô!~°DÓØâB~£À`ðÖ[o-P†Hµæ Û±F¤¿béÌæ„…ÜöÛoßKt×\sMKN×Lˆ0$ÌY@±¡.ûóçk‡…ã’)MJ˜Cº{÷Ï¡ûã Âø7+/ì}â ¡}Úi§ÅQ²Ý§/äs“0éBEœ¸ÎÜc P%0g¤Ï^wÝuUí‹á“Ì}$öå/¹¯,)ag{D üU sââE†~ÂXËÆÁŸRœxâ‰}Š[Ä£ï䞧­þž×<­°f‰s­w1߇c>„wªÌgöLŽv²´â+Jvq?Z²dIü³î…€B@tælªE¦±—Ê)Ê™Vνk_ö©ŒŠõ°?â©`ŸÊ> y? ãB¶CHŸk"ƒÌ…Ñí·ßãBj™þ†7¼aä#xßÃ0•xÉ8öØc‹¥K—NLø¦™a¡l¯j˜TX5}âaÐiØÂŒSD@Ñ e)xøðÂkò˜Ã°4™^ýêWð8UÊ8úW)Çb#Â|-Ï Èg/]9æ˜ÖKS‡0Ç5¹•«?ót |h\ÆqÐ(Mš™F K‡güù aQ‰æiš>oi;Ö]qysæ䑺Ù¦<@9 Ìí-.ÙSÜÊüùϾ¯¼)±ž«È³ÁPÏvØ¡W4Ýîºë.«æÀÕŸe&•¸­°jL]Òãf&uWÌ& kÄTÛ ì8=&3”"ò! Â|0ç=Çr·ì!„¦iŸÓ?'%Ì?õ©O…ñ2ÓŸµ6Ш¸“7Ï ö ™:lìH Æk¯½vß»†à¤I˜t¡È8`uµ+8U iž<ÑEUy´'×ÜÅ"ÜÊÏuažÎÉus¬ïYø3¶¸"h3\qpýQ£®K€"ùPn”Êó@ªÉ‹ænªÎg9ÊžæmŸñㆧ›tn²¸º ! „€è "Ì»Ò*Ç´h{/•S”3-ðmc¯‘¯¹g½Ž'({ <5BÆpe=NÈ%ÛʉkwŒ›âú`…ÌjXØc=B|ä’9 CIßÏ;"Ì›µ –ÇæÕb•y¨,¤Ç2s¯ÎhÇ5ÚØ…Uô°@[ÂM0#kAþƒÌY¼?»@¶1i@îHºGydå$R™yÃ1îÅ–ãx¼Kã,õx XmµÕúÆTƘ2£FžaNûÄ'>1àõCú%ÙwÅà \Žõ¥c7Ÿ!Бa^~ùå}ÏVý`Æ,(U ©ƒ‡ðŒ d{‘8?ºíP‡0çliHàwÞ9h~¦D-e½é¦›úí2ÌØ:…&gK#ÌŽǤ‡Ë¥”@nú<éZ¸á†Æ–×âÖqÉÎ3U s,è­ÍŸúÔ§ö´i-ßôŠ (Îm½ôÒKûÎ%¶x¹Ú‰ôª –wU<í<0«w•‹…øü*žÝqÇ-ëÞ5ƒ§‚aáÙÏ~v{ÒKûÚ°çô}5D˜æ(¡mXöǃwOFxOB˜ãêÛH÷Q.ÇYÜÚ;hWˆüt®ÖÚå± WS…°”È,rø·“.ËHï²3¡ÊrfÜ5ŒìŠDkîjCˆ•§‚òƨÀyM©"ó¸…ue­aXs†:²a&„²ø\ÙðÄ¡ê|–£ìq¾ñ=i§®¹î¸ãŽ8Šî…€B@t#†˜Ç„ÀBG`{©œ2 œiѶmì5ÆëtîÓ£–ÊúU.ÙVnŒ Bb‰Ô%fÿ4°·g? ù¤uŠŽ>/$D˜OÞšÈ.Œ'Yc5‚—ÔQ©a¡œÊÙV_}õp\žù願²Ðž{îY¤†eŒYeG%"«‹­¢1îÛi§Šƒ:(¸+çüt; /•¸l¯+CÄø2Œ;Î"Æ`R9`œÆ¨û·¿ýí½yjË-·¬]§²´Á9djà—iŽŒ¬Ú®²,Ƹ"ÌgÔêX}1XÄeg‚æ.^ `^h,Ëc7B¸Ò¸òÊ+ Î5’Çê!YÌ%‘ÅC€ŒëU\‚Ä–ëX—óMŸ·2U%x‰ßa¾Ê*«ôÚ}Iaå“a‹œíT•`°rUÅóU¯zU¯Îô2KqK3¾Æw<vi¨C˜3¹[äÊæP!"Ì ó*š„h€¢Õ‰uí$„ù.»ìú5 8£œId.¯í=àÜ꜊#© jò)$Ôéu“.ÓùŽ²T{Pp0Œìú¥/}©N±CÜsWB¬”0‡˜˜8ÓÉ°àÊ&,MëÊù…–>çmÑWëü¥Öu泦eqHïm#luÓ¼“"¤ÏB@!Ð5D˜w­ETž6˜Æ^*§ (gZàÚÆ^£Œ0¯rX.ÙVnŒÀ‰cÏŒ8b]ÏÞ½Œ€zÝë^ö4ì¯Øç+…Š€óÉZã°—¿üåaœ@îÜbœV¼ÏÂáý×ä \‘É@js<.c΋^ô¢`è`žû,.Ÿï¾ûîÃÉظQŽ#žXá‚íÑÆõ1©ŽkõãŽ;n¬ñŸe†,ióÍ7å®ãYyR9 å;êÊ|„—EËüœ£NÒ£˜ëÊÚ¬κ.Ô´D˜Ï¨eW]uÕÞ‹i/( «¶CJ `•X5ð,ƒš•hS>ãÏ8gzaŽKÞ”¬¤Þ(l°ÁÅ©§ž:Ôýåkú¼Õ±*ÁKü6sˆ£ØÚ wë¹C“vªC0Pîªxrî‰õs®£¬`c<>üá÷=‡ð·q¨C˜ÓoãrÔ°â|u?ˆ€óÉsDYu s,cñŒÀgÔ–»ñ;À=da®póÍ7÷¥f}]íÓ´,“.±°Å¿Õù#ùHš|éç믿¾¯ø`±ÜrË…ñ ïåñxfqûðäŠE¶ñxüÛÿý‹ßþö·mèõ³ŸýlsRf¼ˆT “Ê«¤õÕW÷Vº{ì±}ïÎQ†I|…DÇSŽpë­·ö•ìËÝuòŠÛ€r×9»(%+?üðJYcMcÄ=¶uCŽ¹« !Ö$„9“øœ­&u½÷Þ{ûÒ>âˆ#êB=¿Î|Ö¤ì'_¤ c"Ì€ôQ! :‡€óÎ5‰ ÔÓØKå”åLË mc¯Ñ”0o"Ûj#Ã*ÝC!çBÎiKLöK¸5†ŒR æõ[÷”SN /xz<묳ú ª¤öûßÿ>Èá‘Wa`†ç_xÒå8 ?8^ðIOzRŸ|åä“OHþ¼óÎ $ûÓŸþôâûßÿþÀïéÈÃ>øÁ”qHxœï~÷»iÔÞg,ÖÂCqJÚ÷"–Ü4‘–$×÷Õ¾ûîÛÃËüqþ}WüpÆgôò/Ú§Nh³þuʱXãŠ0ŸQËŸ~úé}//Ï09‹X—0gñ¼õÖ[+­´RHqÉÊ€‡f YÊnÃsê€&ƒ÷^{í{Æ®hX½øÅ/..¹ä’Ò*7}žD«¼–yù5j­r†yz¦.J9B®vªC0Pî*xB˜§GTµh-³òüå/Ù™ó>8fúÁˆêYæ¯~õ«{c’/lÚ' œdi°ùÊÆŒ:„9 PƈªëFÆ1vB¸Wù‹Ý)YÝŽ>úèªÙŽŒÇûiiÚ5&UG><äÇ& Es‰ge©:öàÞኻû:‹û¸*Mç®6„X©°gœKvê“–ƒu‹Ã¤uMçF6^MCÝùlÒ²+'³¸/1¦(! „€è2"Ì»Ü:*[.¦µ—J×¹Md@9Ó2Ó5>äÆ°ð³Ÿý¬o]‹œ§,4!̛ʶÚÀÈêHŸY{íµû0ˆ½Fn¶Ùfá·Ýwß½uc(+“®B`Vˆ0¯‡<\Æ‚(Úàù°‰œ n7íŒÉ?ÿùÏýª¤²,,¨1PHƒáý–·¼¥2aÌ9éŸüä'ƒR2xÆÄC9$ð==ôPà‰åã¶ù#ø. 0ê„&rÀQùàŽ%“Ñ@l·8§ÞòàzÓM7Õʦ­ú×*Ä"Ž,Â|FÏ"Ž%~y¸?餓Z-QÂüÚk¯-ÖZk­žË Ø·Ýv[Ÿµ`ÂœŠAžbɸtéÒ¾30bV[mµ¡IÓ竼ÖeäWS¼p“bõ¥Ð&MBÎvªK0TÅ3%è8Ó¼JH=àr:%>E˜WAr:qºB˜£eiï˜]SwÍUaQK¼·¸ÊÆŒ:„yš6 à´Ï[<Ü7™+&\3AVWù»øâ‹ðÁ{ î¦×C,ˆ w®“XfÇåh²P<ñÄûʲñÆÇI½Ç‹J\‡í¶ÛnhÜ*?4™»ÚbMB˜§ã1GË”…IêšÎ¸ø÷¾•åWw>ãÙIÊç™Þ³fˆa¡O±ŽRB@!ÐeD˜w¹uT¶\Lk/•®s›È€r¦e8¶±×˜”0Ï!Ûj#Ê+dQ¼OÄ­2Ç’AHq¼rê¡ :"Ì«·ðUW]Ü¥3þüñ•\™WOýÿbâ"'£ ÆLÿ¿˜Eï\ñ‹.º(þzì=r¼ÁƲx¼VBœcˆÁ÷Èt¬N¦Ç«ŽË¨‰pTÚx19*ëݦòÊayayoõGa +õV^}߀ó~<¦ö Kµ-·Ü²÷òØKYŒÖb[¡*aÎ »á†öÊǹeB^£Vv®eæ Ìçcí)܈pÆûßÿþ`½§Áý»ßýîMŸï%äoª¼x 8éfE„ùDSû¢+„9D[üŽq_õìê,óŽÀBp\(3&%Ì[×\sÍPÈÍ4àÞWNÔEqÝZ^“ufÍ^'ýM6Ù¤ÿk®¹¦Îãq›,ÿð‡?ôÎL¢Ž,æï¼óÎ<â/Ph[~ùå{uÀ³Å¸óëãçí>×Ü• ±âùÑò²ëÝwßÝ+7õæ&qÂËQöaeÄÒÄêÃå´ B@! ºŒ€ó.·ŽÊ–iï¥rÊ€r¦–mì5&!Ìsʶrc”ö9Îñ×ø(eÛQiÇ{l]Ÿ…À‚D@„ùøfE–Åñ‰p=‡vX%³(í´ÓNalŸÃÿÅÀ&6B€¬Æz¼ŒËá)dœÈ'•O.Þ“Ï9çœp”ïŠ+®räýð[mµU0Œ°ÿ¿’—ß5‘–§XùRìŽ}Øai§ß¿÷½ïíÍ“9ØFýÓ2êópD˜Ǧõ_pc±Ë.»ô^ [páKâIdÑzë­eœ8T%Ì!&­<\ãsyâô âx,Ó€v%qößÿô§ð™ÁWñÀŽ+#Ô›>gšº”EÛjX(#¿ræL’1fL&o~ó›‹Q.£™`°x„ ûö·¿Ý+rÎv"ѯýë}eCÑaT¨Š'dSܾÔ‡v•tø~gX!¸);[„ùX§¡+„ùý÷ßß;SÇúî£Óñp07ÞxcÁy?¤“ƒÃž+³&e,®û°lgQ˦x / ~ÇE8åB±i nÎ9J-ÁyÇpÕ4à9ÄpçzöÙg7J²éB‘óÙãò°hðâa.šxŽÄ$›ˆ\sý0.?›Óz¤ç$1—–…º„9ùm¾ùæ½r “Ó9êÊÙYq=y÷pW6¬®Ô ²ü­o}kAßeCÇ­:Ÿå({Æ|—öÝ7¾ñâê{! „€A@„ygšBiÖ‹ÓÞKå”åL xÛØkLB˜ç”måÆ(톿øÅ/úÎÀµ= òºI­ÓôõYÌ"ÌG·ÒøÃbýõ×FxÑåøÄq±c<Œ6n¿ýöqÑ{¿c8†ŒÆÆ" EHgÔ1w?øÁÓKdÂä)·Þzk¡ |Ô¿øÅ`À‰ü>–ÕM>•¥<á O¨›Ä@üo~ó›=Y œ´S™WOdr1S5¿6ê_5oÅ+ æ3îwÜqGŸõ› nXZáþ´ŽkÈšSN9¥Xc5€̂3òC$Y\!cÊÂn»íÖí ô|[ÊvÔQGõÅÃÝxLý¬g=«À…{Y`Ó²õÖ[÷ÒÂu¶…¦Ï[:\ÀãúS¯a­®8.÷X é¹Éà_P2ˆ­I—”MÛq´ß×¾öµ`=G[í±Ç®O,äl'Ҽ馛úêüøÇ?¾Ï“7gÐ[¨Š'õHI+,GYz¢$À„hm°dÉ’RëWL,×Qæñ‚¸“LZVw]è a^66±â잪 6Üm´ÑF¡o¡˜Žƒµ/‚;è¸/rÿÒ—¾´,êÐïxW8¦ÁŽnàìŸTQB—1ÃÒÇŒ¡ '?0梵š–KÝ:óN’lø˜.ìvß}÷²h•¿cQ—³îB™±d…V襱îºëö³iAöÞ{ï^\ú ùOrÍ]é¼ ™œ” ¶Ùf›^ÙÁŒòceŸ†º„9mj}Ž4—.]Ú—dŽº2ÿ™×ko´”±ÒxðÁûòãžtvÝuׂy ërꇪóYŽ²ÇùÆ÷ûØÇúÚƒÏ B@! ºŽ€ó®·Ê×Yì¥rÊ€r¦Žmì5YÙzÞ®È+G…œ²­Ü¥åf/}ÜqÇ ÔãT›>«ÏB`¡ Â|xK¢8óŠW¼"³x`D~ƒ5ö°?#œ8à€âIOzRðLËþ‡çTx/†˜·±y JC©|dT¹~cll*O´²4•Z:ñu¿ýöëá„\°êxã¹çž[ ÏðÎH;Ð&´Å$2Û6ê?ªÌú­æýxLýƒ ®ÓãÁ m ´QöÙgŸ±ÖƒXM⾋ݕVZ)< yËÂ7 7ß|sop ¬›Ë¬.=ôоx¼è” §{½‹QΖæ „Ù6(s…Ôå¥FÀÎæ6a4BþQî‰8ÕÒ¢üš>oép½øâ‹{y¤í°2umKü2L-}÷V~®ÃH"È/;9Žv(J@x }Æ ºóÎ;)à™Ì9Û‰z )—‰~hÄ”˜ôÍMn<Ѧƒü‹ÓGI¢Ì²‚«A‹û¢½(ô)ÃÚ®¼?1©NüøŒw‹Ç• ö¶4¹^vÙeqÝ7D +„9Õ ¿áº:noˆ5¼9”‘oVu2—\rI;h¬·y/qmT%`çÇ=JUŒ?üpu0 ä˜Ü}Ï{ÞÓ—5‹f\Y>{íµWßïu>œþù½t,=4YQÖj³ñÞai‚ïê¤O–WÚdظ]–c.Êd–¤,ç×6}Xp[\”,¨Ï$!×ÜE]S%+Üz1ï³ ÂÃÀÇ?þñÐgûØÇöÊnu`.æÌ(ú˜…”0Ç;ŒëÇ®?ûÙÏúÚÀ$U ÉQWÞ=£¬Üv¥î(rpÉYgUà6‹2p„À2Ë,Æõ2WcUç3ùÈkÒ5ŠáTvÅõ–Õ…ÖO B@! ºŽ€ó®·Ê7)³ÚKå”åL ÛØk ã±5°]!ŠF…œ²­Ü••yFAV?®ì¯„ÀbA@„yyKc|³å–[öSxŽjõ‡gJä©&³69|yÿó-Æ@p È=ÍC"ë7<>V±f•v~k*L뀼 C ³?ð¤Q†~FN‹Ì £KÚ ¾£’4 ÷d ùÐæÈ¥& ¹ë?Ió3"Ì;Ðú)XBaíŸÎË…ð­ÈC^f^<´Y°:†¬D€üêW¿:ë< aþá¸@ÀÚ¼ä68ØõÓŸþô™KxÓ†±xË.»lxÙ9+vÕž|oq¸2x ð´§=-Áéü„;ÜT0ÒÀSžò”.¶Ñ®²ÐôyK²àõ¯}_Y™T ÒÀ ‡P>®÷'tR)ùņ µ^fñ\Öäñ[ÔÇù@R3I¢Uf ¬¨QDHI§œíD¹ ,b¢‹rQ/ÜÈ¢-‹[u¬ÜÙTÕÁ“´ ”—…€Õ—úAàÚÍ+õÂ… sM_C/­;éAPÚÂÀÒä¬ê22÷%Ë{5N3Œ|ª!Ð%ÂœÓæŒCÖ7¸2nmºé¦pc¬„tdLe€XDñˆw€÷þyÄGã´áé›(#±(ŽóârÅÒÁ½4ãZ‰\9ûŒþúÎw¾3¹ð‚¼ ·@¶të-àN ¥Hmû}­µÖ*ð†Q7 D8ýôÓ{éXz\iG\ó5 qÚÌMl& #²á†ö•E¯º¤þC=”¼hWêHÇØR6ÂP2,ð00i¹I/×ÜEZ©[AÆ2”ê(#kæ¾Ãí–m²¬lÐ6Ø`ƒâŒ3Î ©ØÜÆsGúŒÿ|Ÿ†\u…ügÌ·²Û•6G‘ ë³vç}FY Lñ¯ê|ÆûmùL²FI±°Ï(~-·Ür½´Qª«¢SýëaÈkÈêÛËqΠɋNjºæškœÉ‹™¸X`a9ùÕ¯~uÀòë¶Ûn+°RÜ~ûíûSK›4yò݈ÈPã©-^|…ÌdQ ±º€% ébA:¿A`aMŽ&Ôi§¬©± æ74v °âÍyÓç!E:è bÛm· ÈÒ¢À¬ßqÁYª©«oââš‚¢‹ÀÙëXƒcý“ÄeÆõ ¿Ói;Ú%uA˳öGX¨Q‡28g;Yù¨Úÿ˜ìé ”å£ýh-<-]®Ó(‡@ˆ› ÂÃ,ë9+r ‡º¿éMo*®»îº÷%|G¼†•]!S (­ÿ1iAŒ§ŠÄgq¢ V‹ Í°EDÙYóÍS¯Ÿr6ÞhÿÅï}¾ÂûO¹W[mµ Ðcï1ßò“Ÿ«™‰b bH˘ȶþÈ•¾ÎXÍÎø‡¶!W>£ƒå{ÙX‹2’¹ÇýÄ%J+iÚŒ?Œ×eãLŠd(ãï2sHœ–ÝóþóNòÝwß}i•>cÅ¿sõWUé9"a5…q›ù0n;+#›ÝüÑ!)N>ùäJi㚥Æðfü@YyˆtÐþdî2ò˜±ªIh:wÅyÓx=°ú§Wêıh¯ÆÖèŒqÌÑÇsLŸ·fÜšæ+é1£´æx10å8Þ Þpò«®Ìsx a.({'âz£|…æõ(…–qóždr•=Å…zXèSM•PÒôõY! „@[Ø>-Þ“·•—ÒÓ@ +{©2 Ã+gZ9öìPîfïÁÞ!^·sÏ~™{ÔG€±È[ˆ:O˜‡÷½~ ùŸ`Šc ¥ÏxÅ“ðÎñÞy¯Î+… é_ô;Æ3Oœ‡÷Ž>á ÕÞx8¬d¼+~aƱaq&ýÞ“êÎÇáqú;}¹lʦüŒ½ŒIÌ£s‰wwç¼õíÐùÀžg¼ö¤jÀž«sõ–¿îmo{[(³'õ÷1ð.—¥çµ3ÃXì½N8¯0PZgžc,öÊdŽñ›rV Þývs¯¼òÊ0ÞÒ˜¿IÇo6œ×Ô ã.cp:öTÉÃâ0ß6™û,»þà?pþ¸€0vÒ§3ý‚Üy¢ßy‚Ûy‚ÛyAT?éË^a+ÌÓÌÃÄóÊÎ+CXrŽq×+Y8¿Ñuþ<ð€ýÌ=Ižñ×Î[±;ON;O¦‡÷¤—@t“³®ôqæBÚè‡?ü¡ó»ŽyŽ6âà:3Gx¥Œ‘ïè¸ùŒçs–=‚ÄùM•óÊá+o]wXÅqt/„€B ‹°Æ²µb*[èbyU&!0.í¥rÈ€¬¾9Ójº×@îå BÂ^¢L6F™O»±·ðÄ’U£wÍ-Û"áœõ ú¿7þˆ?çžÑ+ËYiGŸ…ÀBE‚?vÓù£Ò‚l|¡Ö³N½ “=WMÇÝ9d«q€SoäWÈ´VöœqàeàRcyÏ‚ñ#swߦ0˜s¼ÑcÀ…v:äC*c„ü ^ ™2Ü—µ1òBäSðspüy#ÀJ²ä4ó¶ëŸæ§Ï£a>Ÿ™ý ‘Œ —?ˆ^6¬¸l`ì³ e±‰€Ü[)ìC”3¨Ž ¼è¼ä1A€@Ý»d» â½Æh¨“¦×Ê BwíÙ!ž¼!à ¿ýyEÎ[¥‡2ÂxêD}xÖ[ô…¸õËø¦Ï“ϸ@½Ü „!­GHVomp©‚-˜iºäEù('ï‰KÛBV {.N'G;ÅéQž¿ód9íd›ˆ8—ºxÆéÆ÷ôe6/” èótôgêÎe¡JŸ¦_Ñ!EYPŒ (‰ŸB3ºH˜[èo¼ÛŒ;üyËÔ0¶šÂã*ããP•÷Ž´½«œ¡Š–÷¤WÊcc"såxGy‡FÆ ªÞ!Þ¥IïŠ((^Alûc%‚̸´ê–˜¹«j / ´ec.cã­ý±Ù0űªi–Åk:w•¥IcÜdl'ú®ÍÉÖölè¿ôæÝQ2Ò¯lb­Á˜’¶Œý£Bu¥}»)õ%úÔ™wµJ5Ÿñ|egC…"ã<ÞPÚƒœWB@!0ˆ0Ÿ‡VRë е½TÕ?gZMö¬©Qt­Øw!ÿ+ ¹e[ä‘£¸ÌÞª<(Å¢l!û'!°Xa>ØÒŒŒ…MB™\CÆ1d<È®‘Ï 7‡'óiR–i>Û¶cR¸òC“µV­#ó£·2EdËŒùàÏœGÇߤíÑvý«ÖSñþæsÔ°‚ãSšÞsÔp*ªX$t™0/kSQô‰-oËâê»É@Y +k´0ñ<ò¹Ï}n,©?YN“?…²} V›<5=¹Ø`\ñÇ€8¤Cèëþ8ç¡QÿZìCõB@Ì"Ì稱TT! f‚Jx¤ƒD9óÌ3å±p&­ Lg‰€óé¡¡ò* 0¬‘ürzØ—å„RrDñseè,ŒïD˜/ŒvT-„€3G`Þó™¶ ÀBWuK–, Ñüà?;hÔ\U\¬ø32Ý»Þõ®à¦ëÈ# ÷XÅ+! „€˜D˜ÏKK©œB@Ì “O>Ùù3Ûƒµ'Ä!G`)Å„€óÅÔÚª«X\ˆ0_\í­Ú ! ZC@„ykÐÎu¸+Zºt©;ðÀƒ óÆwÙe—¹®“ /ʸôÒKC?çØÎÄâs ÏÊÒwB@!ÐeD˜w¹uT6! ¦‰nrùc\´pÓM7/j_Éò\A,6D˜/¶W}…ÀâA@„ùâikÕT!Ð*"Ì[…w®ç<êsÎ9ÇaqËYAhãï¹çžrS=×­ªÂÇ|ö³ŸuÇsŒ»ûU9dùSŸúÔ8Šî…€B@Ì"Ì碙TH! ZFàßø†;ûì³Ã¹·œ+¼êª«†³j9réÛßþv8‡ý[ßúVø¾å¢(y!Ð9D˜w®IT ! 2! Â<JF!°Øa¾Ø{Àèúÿö·¿u—\r‰;úè£Ýÿñ»]wÝÕvØa;Ó|t-ô«DàÔSOuýèGƒöÃ?Üm·ÝvÁ=ã`L}#„€B ûˆ0ï~©„B@´À&›lâ®»îºpV-G,ýÙŸýYØ»Þwß}Áêü¤“N Š²œc« "Ì[‹«¾B`ñ Â|ñ´µj*„€hæ­Â» ÿÝï~箿þzwæ™gKÜ¿ù›¿q{ÜãDÝT‰Å‰@QîÅ/~qðœ°ï¾ûº—¾ô¥Áòdq¢¡Z ! „ÀB@@„ùBhEÕA¦à-êW¿úUi2›nº©»ð ݓŸüäÒßõ¥Xèˆ0_è-¬ú Å‹€óÅÛöª¹B +"̳¹`ã ¸;ï¼Ó=ðÀnã7vzÔ£l]U±ÅÀ5×\\2â¦Q&‹£ÍUK! „ÀBF@„ùBn]ÕMªì¾ûîîÜsψ¾Í6Û¯iÈ?„ÀbE@„ùbmyÕ[,|D˜/ü6V …€SA@„ùT`V&B@! „€B 5D˜·­B`Ž@ÉûŠ+®pßûÞ÷Ü=÷ÜãžùÌg:dÛo¿½[}õÕÝ#ñˆ9ªŠ*ò" Â+䕯B`! Â|5¨ª#„€B@!°èa¾èš\B@!P æµàRd! ææsÔX*ªB Ël½õÖîöÛowW]u•[e•Uº\T•M! „€B@žûÜçºÿ÷w?ùÉOÜ#ùÈ’úJ! „€XÌÜvÛmn›m¶q/xÁ Ü¿øÅÅ …ê.„ÀC@„ùkPUG!0+Ð0ýýïïÖZk-·Ì2Ë̪ÊW! „€B@ ¸þúëÝÿ÷» 6ØÀ=â˜0=&„€B@,TþùŸÿÙÝ|óÍîq{œ{á _¸P«©z !°a¾]UB@! „€B@! „€B@! „€B@çD˜«! „€B@! „€B@! „€B@! „À¢D@„ù¢lvUZ! „€B@! „€B@! „€B@! D˜«! „€B@! „€B@! „€B@! „À¢D@„ù¢lvUZ! „€B@! „€B@! „€B@! D˜«! „€B@! „€B@! „€B@! „À¢D@„ù¢lvUZ! „€B@! „€B@! „€B@! jæçwžûõ¯-ä„€B@! „€B@! „€B@! „€B@Ì å—_Þ-Y²¤Qþµ ó-¶ØÂÝzë­2ÕÃB@! „€B@! „€B@! „€B@! š ðüç?ß]yå•M’pµ ó­¶ÚJ„y#Èõ°B@! „€B@! „€B@! „€B@4EàyÏ{ž»âŠ+%S›0ÿþ÷¿ï~÷»ß5ÊT ! „€B@! „€B@! „€B@! „€h‚Àã÷8·ÖZk5I¢¾…y£Üô°B@! „€B@! „€B@! „€B@Ž PÛ¼#åV1„€B@! „€B@! „€B@! „€B@4B@„y#øô°B@! „€B@! „€B@! „€B@Ì+"ÌçµåTn! „€B@! „€B@! „€B@! „€h„€óFðéa! „€B@! „€B@! „€B@! „€˜WD˜ÏkË©ÜB@! „€B@! „€B@! „€B@!ÐæàÓÃB@! „€B@! „€B@! „€B@!0¯ˆ0Ÿ×–S¹…€B@! „€B@! „€B@! „€B "ÌÁ§‡…€B@! „€B@! „€B@! „€B`^a>¯-§r ! „€B@! „€B@! „€B@! „@#D˜7‚O ! „€B@! „€B@! „€B@! „À¼" Â|^[NåB@! „€B@! „€B@! „€B@Fˆ0oŸB@CàŽ;îpøÃÜꫯîþäOþľÖU! „€B@9Aàæ›ovEQ¸µÖZkNJ¬b ! „€ÓDà_þå_Üüc·Ì2˸UW]ušY+/! „@«ˆ0o^%.„€X<,Y²ÄÝu×]î /tñ±x*®š ! „€B@‚Àlàþã?þÃ}ï{ßs|ä#H­T ! „€B wÞy§Ûu×]Ýk¬á–.]š+Y¥#„€˜9"ÌgÞ*€B`a ð¢½ÈÝrË-îG?ú‘{Þóž·0*¥Z! „€B@E„ž¢þíßþÍýçþ§û£?ú£ETsUU! „€¨‚À÷¿ÿ}·öÚk»—¼ä%îÆo¬òˆâ! ææsÑL*¤B ûˆ0ï~©„B@! „€B`"ÌG¡£ß„€B@æêB@,TD˜/Ô–U½„€SF@„ù”WvB@! „€B 3"Ì3ªä„€B@,0D˜/°Uu„€è! ¼…n„€B  "Ì› §g…€B@! „Àìa>û6P „€B@tæ]n•M&,hÂüë_ÿºûùÏîvß}w÷ˆG<¢ NzvÆ<øàƒî¯ÿú¯Ã¹(?ýéOÝ\0ãõgÏoÿþïÿÞÿåˆO|ä#ÝŸþ韪_ŽÀh?ýâ¿pgu–ûÕ¯~Îà^²d‰{ò“Ÿ<‹¢Ìež]$Ìýë_»›o¾ÙÝqÇá,Æ?û³?sË-·\hßg?ûÙ½wð®»îrŸÿüçÝ.»ìâžö´§õáÿßÿýßî÷¿ÿ}ßwé‡Ç<æ1îQzTúuíÏEQ¸þçùãÇ2Ë,ê³Æ®â<¬1rô­?üáî¿þ뿆e1ð=}Œ¾Öõ›yë£Ú$Çz´î:ãÑ~´ƒðèBÈÑþõ_ÿÕýÇüÇØêØøHDÆGp«âçâøuÆäø¹:÷œü/ÿò/u©÷±}lo¾«ýpòÀ,ûbÓ¾´Æ•¤YôQdE`V„ù,Ç—¬Î ±iïc§ß m”eݾLf¹ö“ >GוÖŸŠº{½:yÖé/¬®½öZwë­·ºý÷ß¿N6Yâ6]¿e)„ÉŽ€óìÎE‚9Ç“‡zÈýä'?q?ûÙÏã{ò§>õ©níµ×vÏ|æ3'£4'*ˆšk,aŽ`m“M6 /Üg>ó÷â¿x®j±Âè–[nq?úÑ•”Á“E.BÅßýîw‚ä£ý¨ûâ¿X¹L(pü¿ÿ÷ÿé…ó Ox‚[e•UÜꫯþø¬0}ÞñŽw¸‹.ºÈ±±ùó?ÿswÀ¸Ñ­¼òÊîe/{Yxçþê¯þÊ]uÕUîSŸú”Û|óÍûZ€t ÓG…]wÝ5í£âTùíºë®sÇsÌȨ+¬°‚;÷ÜsÝBwºŠsÚ9ûÖ_þå_…Ž4aŸ×Yg÷|`ØÏ3ÿ>'6óÒÆžk=Z÷}g³ áñ¸Ç=έ¸âŠaœ{þóŸï^ð‚„è¸rçø=W€PÞi§Ü?ýÓ?-ue'0.£W%ÄÏÅñ™?vÞyçø«ûç>÷¹î´ÓNø¾ê(„qÄU£OïŸø„{Æ3ž1ѳéC³è‹¹úÒBWÒ6Ñg!Yæ³_rc7«ô¦½v~³ÂuÒ|—.]êCÖ (Æ¢ýøÇ?ޡؽꪫ9æJ+­T'™·®Œ°nü6€«»×«S†÷¿ÿýî%/yÉÈGPüüÖ·¾å.¼ðÂ`€„2éí·ß>ò™œ?æZ¿å,“Òʇ€ó|XÎCJ9ÇÆ" !›ÕÂñÀõÀ•`\ˆáÚlàXk@ W m¤Y%_ÅY ø¿ ׿üåÂ/8 ßlÅ[Þò–YÇ…\©/}éKÅZk­Uxá^á7 ¡iKþü¾sUÿÚ×¾V¼ë]ï*¶Ùf›P>+먫Ÿ oVøÉ ðyᵧB7ÝtÓâÝï~wታÂ[v®® ¹@ÏzÖ³úúÚK_úÒ…\Ýìu{á _ðóŠ.ÙÓ®“à½÷Þ[l¿ýö…_XõÚÓ+@~CYxMÅbÙe— ß{ò<Œ1”Û[ž‡ï¼0} «+®¸¢ðŠÅë^÷ºÂ“O½4ã÷›t=16ðlÝ/¼…{iúäµæško}ë[‹ÓO?=$»ÐÆ®â·aî¾uÞyçûî»oè›qŠï™'¶ÜrËÂ+ð~C§S÷¹±™‡þP¥r­G½òO±ß~ûm´QÁú!î#Ãî=i^0Îy¡Â ^C?{ó›ß\|á _(¼µv•âO'gð„yá åbýõ×Zï5ÖX#¼#žlé•ùÃþpx¿¼’QésàÈ»uÈ!‡ûØÇzÏÅ7~ó^~øáÅk_ûÚÒõèvÛmWÄyÆÏV½÷ —¥åÖ®“|ïZU‹36Þ´ûbξ´PÆ•±¤B !ÌŒ5Œ¿Ó Ó_¦Y·¶óšö>vÚùµ_îô¯¹æšÂ[òÞˆ§`=VuîF†‰|ˆ}ìj«­Vl¼ñÆaâIÎÜEœ»ôêÊëÆo*{½ª}#Gý†oZx¢¼ØgŸ} d&SEî8­sý6­2+ŸzüíßþmÛ³),\r'÷Ýw_±Ç{ñä\O8á„âÒK/-Î>ûìÞžîÖ[o]xcʱඑæØLaA#°`-ÌýKå.¿ür¿¦pîIOz’ó¹{úÓŸ>ë_÷ðƒ]p¿Ž5‘Ñ/Ÿ@IDAT_dºoûÛ½B£ñÞ¶ëÊ^fop׌VåõÂ8wðÁ<‰¥“'ñ‚‹P,–þþïÿ>X¾þò—¿tW_}µCûÒn£ý&ÔùÅ­ó‰óBbûI×ð î²Ë.ëå°Å[¸+¯¼²÷Y7£è‚…9Z…¼3Ÿýìgƒû^4ù¼ãŽ;:¬ÊqÄ{zçwºSO=5¸ÿ‰kuä‘Gº£>:þ*h;>üðÃázÓM7…c>°xŒ#ÈÓ“'ñ×µîï¾ûn·îºë†±$}ГdîøãwOyÊSœ'üC]Ú¸ƒViq¶¶h£oÑùÃ{ í[æÉàØc ý Ï#´=] m`ÓõþPµ r­GyßY7ð‡Ãq`¬;å”SÂÁzä·¿ý­»ÿþûÃæV½¨¸o\Ù{×`~óDpð¦Òû1ÓMîþàwbÁRüp~3ÆÚ´¨Ÿüä'ƒw,³ÌKXÖϯ³xWoX£³OÖ^i`ÎàýäYÖ£æá1Ÿ9äå/¹[~ùåáˆg›ØŠwüU¯zUXâ…ˆ?¬Îpí¯Q(+kKêÁœ„%Ì%ßøÆ7úŽ÷¸þúëƒG•´~“|žf_ÌÝ—ʸ2I»é!PYY˜Os|©ƒÇ<Äö>vÚùÍCÄeÄcëÖcx2óJ|ñÏáovìñm?¼,â!wÁëOž;oTäIöýb»Ö•Ößžãöz¬'?ô¡¹2/¬éô%\ ç;ßq^ÃὊð¹Ï}Îy…þ¾bó k>¬6o¸á†°&dmh52ý¬í{ýÖvy•þdÈÂ|2Üæå©6ÆƯ½÷Þ;xèežC.0<)2>1Þqœ&ž^ñŽÁ1sXš³Ç#\Yh#Ͳ|ôÝ"CÀ¿ .üà?°<î¸ã\=z…°~ò‹»Â}¹]´0Û“á…nö•+&ú%Zú~ñXxR¨ðØŸÓQüøÇ?.°xÁzÐO}Ï¡]Œ¥½ŒO]ß:QFOÇÕ›Ëûªõ¸öÚk‹m·Ý¶ðÊ5Åf›m´rç²Â3*t,̱ß¿7¼á Å=÷ÜS ¿y-ho¬y?ýÔþöÚk¯8ÚÀ½_ÀÞ¥q/¾=Çõ•¯|e#¯XPÆéÅ÷hZŽ iÜ¡ž]Ĺí¾åh¿iãð¨¶ïÂomcÓÅþP÷¶Ö£ó73ÐW˜·<©ÖXE{ÁZñw÷w…W8,X{R·ï¼jøÍj£1kmö<˜x¡b_]+ý1ʼtÐAÏ`¹•Î Cñ?‡ËX–³–ËÎ9çœ^º^ñ¬ð ¿amèÂûï BÛuÔQ½xV¯(~#kž¹í¶ÛŠ¯|å+…wåÚ‹ï ôEH£í¾Øf_š×qe ô…hYY˜ÇUi{|‰óZ÷ÓÞÇN;¿yn£Ÿþô§½ùØæo,~‘áQПwÞ“aIŽåð;ìÐ÷ ûU|_˜ã狦e¯+#¬¿iùF=_¶×c­†\‚~þ!;¤o e¯ÿÃþ°`-h² ïÎx ; @ð(å/ ¯TY¤^–Ø[N#´¹~›Fù•G5da^ §yÕÆxrâ‰'öÉká:Ê<ßy¡žg <¯ì¶ÛnCåm¤9¯m¦rçCÀåKª;)áÛ¢vÅÅ …ùC¯µ#×®æ ü´§=­¯Ì¸á*›¬5Xÿüç?-GØ"Øê»v\†ŽJÃÒÊu¥L¸à õ<‡:õÀ¥6‚fÜWAt Ü P.æÞÚ¯ïÝóÖC+Q‚ÂÊk^óšÞ3¸çp÷nïf|EÁrj’à-‚¢Fœ^|?ª–ßBw¬.\»†sÛ}‹9 nsîýÙÈ1$½o›.ö‡*ÑÖz”õlÚWüùäC‹yÎfÔ[±ô=ç-™ ÜçmöæôÃ;¬¯`áÏ8YŸüä'áø›7Ö“u\•ûs({ù¢è˜+œqÆ!]„ç¤KËÂ?øÁ^þVaÇ4 dõ^OzmÞFh»/¶Ù—À£kóLm¤4…À$t0o{|™—.?3í}ì´óë2öãÊƼΚÃæn®Ë-·ÜP¥=d>È$Ö[o½¾gxÎ{¤úܸr,¤ßëÊëÆo«²½ž÷.W+«_ýêW½£¼Ê”EQ,õž‹ ï¯ð‡‚;ÿ¸ßM‹0o{ýV 4En æ­AÛ‰„s'(‰ÅŠïÈQú. Èâßô¦7õæ@ŽÆäØž4´‘fš‡>/NaŽuEªEÇÂÒ»BZœ­<çµfQ/òæ0‡äˆËüGôG•[ dÈq´¨â48¿ã#ùHåtšFônJù§ó~Ž÷B©GÓöœÆó³&ÌÜ@ÅïM @‚öÎb=>.,Y²¤/8?,Ú' X›¢ Ù8MîÑ(¬öì<Ž;q»„ó4úV™`xΛ6ô‹.õ‡¸Ÿ»os= jï¹]Ç]ô/[üÛÎ=÷x’îeËFÉã½;ž3Rïpm¤9ªLúmñ °às®ctˆ_,îñÂ+Ì¿þõ¯ûÉy Ìq—÷¿:Ä­ãÏ5/ÞùÎwö¥Az¸\Å5IÛá{ßû^ñìg?;ä?Ï„ùB©GÛí+ýYæþ¬›ñOã‹.ÜÚòŽAºŒ o~ó›C\”XŒä¶÷7ÇUÈí86µ½@xCa!héÙ+ƒqaÞÇ´~]Ây} rËÚÛ®“QRÛþ< l¨C—úCLÛ^Z±ë8Âœ2£•mñíŠg \Sç Óèß;î¸ã@]Æ]ÁšZ«;W´Üqe?. œ6…,,Ís†cŽ9&” ÷•£B* üÃ,Ì-\wïÓŸþ´}•ýãÉ}®¾8¾4oãJöÆS‚B`] Ì)Z[ãËjëk!Ðì1ãþ\…0‡x|âŸØ÷i\}õÕ­•s^®+#¬¿ ríõðŽ„Âß7¿ùͱżñÆûúÏ4ói¬ßÆV\¦‚€ó©ÀÜ™LšŒ'ŒÆ1Ø\HÿP2ŠçÀÇ<æ1ÆNÚHÓÒÖU,(ÂÒ³ÿxù6Ùd“p6­½ˆ\Ùøµu†ŸºR{taq[·vM‰+òõȚk®Ù·À¥snfªUU·|£âßwß}EìBi^ ó…RQmÕµßfM˜CŽÇc>÷¸ñ©¢(õÛßþ6(¤àÙaydv\¨™õ^œï;ÞñŽZMƒæ¤¹J†8yãß8PiæzVãN`]Ây}+—¥ Ë6¿›6”¿KýažÓXÆc÷UHJ¬ÞS%žå¼Ì\aZýá²Ë.'Q0µ>Âz;³ÁƒóÙÆ…}ìc!?戺JQãÒ^ºtiñÊW¾²¸÷Þ{GF„0ÿë¿þëbÓM7-8 ¸­ÐV_œF_š§q¥­öSºB  y&̧1וa¦ï„À(&!ÌIÏö×ñ\;NÁnT9Êoue„uã·S®½Š¸[¯¢ðÉ:0î;Ó Ì§±~k£}”f}D˜×ÇlžŸh2žpt%†„6=þñéYÍpÚ`ƒ zÏð,ûa m¤iië*aŽåŒ‘¸¼æškƒMÏcFqÁ¹0±«–k¯½¶¸øâ‹‹/|á A˜ÆB¦nÀj¢´°ùÚ×¾Vàz² áS–çä\rÉ%Å<Ð÷3¤çžþùáŠà°Àâ,Á”ºQÿ¸îÞ‹¿ç\ 4®ºêªâ‚ .Z±¸¯R¯*‹Ûßÿþ÷aÁÈ¢qØ_™›K\j¦ñÑbjr攼SáöcûØÊVæ¿ùÍo‚ôsŸû\q饗†¶Õ/9Ûi‡vès¿Î:ëôaÖãBÝ|G¥Gáàý¶w‚¾TÖž–NÓzðÞ|óÍÅå—_nIŽ½æ|wÛgÆVf¶¡µþ&Lj¢Çèwéû‚E în«Œ5Ýhû§ãeZ°CppÔ‡-úìºüòËâ9}nØçm¶Ù&¤Å:có, sÊØtÜVϺßw çiô­\B”º87? l(c—úÃ8̦±µñÆ®Us΋7ªöls¼ÇÕ}Zýµ^w¬\Ñ:W—ý÷ß¿ïžÛ|óÍGV‹9yýõ×ÏAÊZO²ÞÅ«Ð-·Ü2vžš„0gBÚUÖn#AñcÜÜçê‹ÓèKó4®Œhý$²#0Ï„yݹ™ŠSìåŒùXQ!×ÁØbÜøÉX…RRÕýö¨Æšdß›¦Wg‹Âðõ×_äì{o½õÖÞ‘#ìµGÍw–oü쮹öÎó²ož„0§nO{ÚÓÖ-ÈðꆮõÓIÖKq«È›ÄŸÍußd¯G_àxÆ*Våqy›\q:u~KË“k<‰ÓÍ1wi~‰ë–ë^„y.$ç#&ãɱÇÛ7—U=zp¿ýöë{Ep m¤iië*^¸± ‚'ÃÝç?ÿyçÏtþEvžùä¾ïâ´»wë¼æièK^1 ×/½Viè `±Ì2Ëô£¿xëÖÐ7hk ´‘ŸÌì£óÖUÎ+a8Ú0 “䛦aŸé+ô¯4úïå¢ý)÷ +¬àüyŸ¡ïø³Lí±Ðï'­x}ë[ß ܃ՕW^ÙK»ì&×»;q¦¬ü9¿ó>œÌ;O˜»ç=ïy9“®”–ßH†q×+XôÅ_qÅÝÎ;ïìŽ8âˆ0îôý}¸çž{œW2rÞ1ô³è§¾ÛÝwßÝ{î¹aŒðÂ1ç ç•ŽúâÐßûÞ÷ö}Wö¼›yGßúÖ·º³Î:+”Õ îú¢3Œ›·f=îô8Ç.á<¾Åxï¢ú£o1_w9Lêߥþ0®=ÚZÆù²‹ƒ')Ãø—Þ³>\yå•Q–íû‰yÌ+ õ}7é‡iõÊç•œÜgœÑWÔ÷¼ç=îÄOìû.þàÏlw^)5þ*¼wžìëì¾þ÷sk1Öž§Ÿ~úÀZ’h9Ö»eyÇßüñaç ÝN;í5õû¶úâ4úÒ<+SoXe¸¨`¿åÉÒ°e;«ÐÖøº›õ•Wps^àï7x«È 9ú裃ì‚8ààKrŒµ^‰ †.ì{ãÕÙÇ"—`þôÆ Î“[a~C†Åžš¿g<ãá{æ—׿þõq6½û:ùõò79öÎó¸o~ò“Ÿ05,XwŨð‹_üÂ=ëYÏrž¸ë‹Fß{þóŸß÷Ý°]맹ÖKUd„1&uãÇÏæºo²×CFá•7Ã~ˆ1ªj`}Ëòo!Ûm3LcýfåÏ1žXZvTiÏwm~±rµqõŠÊníµ×},æ]ÚÈKiÎ&ãÉf›mæ¾þõ¯÷*Áú‚µÕ¸àŸÜÁÜ‹æ•È¯Åm¤ÙËH7BÀ/6Dð„vá‰=$€ÅûÞ÷¾^pWÄwñŸ'{¿»ÁJÈ¿ÈÅzë­WøÅj°^±´°<ì°ÃŠÕV[­Ôb‡s!9‹Ö“ë#³Áj-¬ýèGKʈ -hxûÍbûœ6Ú¨8ï¼óJ­PÐlö‚ŸàNÛ“ë½³)/®+Ñœö‚Â+F«C|]n¹åŠ}èC¡¬XâÖ>Õ„µøÔí5¯yÍH×Åh¾n¸á†…ßžà çì ÉYÁ`Ê9’Ô‹²žzê©CÝhVÑõ$gáÉï>Ëh++˜q–hÙùX]s¥Å¥<{ï½wpq4²ÑÆü˜ËÂœl¼C¯|VNOŒ•âåá…'ÒƒËQ,Ñé›~)pcâ7¿!êˆín»í,·­*'œpBá7^½x–[ÔÇþ<ZxòÚ ×&ùö%ô¿Ðœõ›ó`=æ¡/¾ýío/°6+fÞÎ{ÞsÏ= 4”-Ô­ï'ïà[Þò–ð¾y—ðÎQúæ¨ëÝÆ83ª¹~³¶™•…9õ` ³¾_9ûÆ+æ~‘VúîÔÁÀ+ù„<°0'ðÎÅyqïI©±c?ÏšÆ$ý÷e„Y[˜S†:ãñÛ]ùí¾ÕÄê  üë¤Ù66”¥kýa>m­GÓüÒ1§ŠU/k»ô9ÎÃ/g˜F ¼œIΚ&®“ò÷¬ãÒ:Ñ6¬âøvï…iôÞç#<2<Ã:Ê ¯{ßÛM®õ®¥7ì:‰…ù°´r~oÚ5g_l»/Í˸’³½”–¨‚À<[˜šëØczƒ†bË-· û^o4Л~õ«_»îºkO¦dc{ÎøX¿.í{'ÙÇ2çƒÁJ+­ö¼{íµWðÈ¾Ö ¥ƒ Ù GwÜq}Ýe’üârìçußœÊÕÇŒ žt rMë‡vEf7îø0ÒíR?µzæ\/U‘Z¾\ëÆŸÍußd¯g^í× M,Bëä“Æm{ýF~9Æ“´ÜMä]œ_Òúåþ, ó܈v;½&ãI:tÐA•* dóW¼J›÷›6Ò¬T(EZ,—ì×¼<³¼•`¯ñ¼&aá­ û^0o™Z°!ªØpA²xKê¾4È ÷î¼ Â[mµUp‹_f\_zk”¡Yáêk•UV ä1„ d¿× 9\³3A2óé"ôôÅá‡>æu×]ˆhHϸ ÜC¼{«ð¢› " -‘ôŒlÜ["ƒh%.gY¿ímo ›*HœØ•'iˆø²€k/Êiå }¼rpíÍâÝ[釳¸íw\Má2²,TYÜ2`zKñ‚ Ÿ¥iWÈx¯åWxMêäqOŽ»o6„ćÃmN÷͉E_ä$̽G„:=®Žâ@ý9äÐßi;6´$ýˆ¾· q8Ý&Ú„¼¼S_~ó|ÿÅø4Í7®÷”╉åÞúnÖQRñ^‚òˆµ/Âoú—…ºõàhÜÁ 4°4í:Š0Ïùî¶=Î6m_»@˜3¶›ë\kG»Ò§ä# ¢/MR»×l.˜W,®(¡¨3*@¼ (E|ŽB0Òª „yÕqgTýšþÖ5œÛî[M„(M±nú|ÛØP¾®õ‡a˜µµMó‹ÇîÇ‘”¸]E‰1}Î{ÞH“nüyýB"0N×¼Œ½Ì©eR<­¿}f-^vÔ ëD~#ã4ì8ä\ïÆé–Ý/¼N_l»/Í˸RÖôhy%ÌÇ/ƒ„L$U¶bŒç;ß”ücÝæïõ,Àݵ}ï$ûXH&HWꆜÙòþî¿ÿþ‚º²gâwï-«¯›M’Ÿ%kï<¯ûæT°?Ž0÷䘬q Ž ]맔7÷z©ŠŒ0Æ©nüøÙ\÷“îõîºë®Â[ñ†wr^ó¶×o¹Æ“¸m›Ê!»6¿Äukë^„y[Èv3ÝI söØÌ_¶¦âʱ™UÇÝÄÏq,·4«”Gq ‚0gc„E /Dç—ÄáÝï~wß Æé´ÓN‹£ ½‡pç,'61YL^ØXï^qÅá|n6LÛo¿}_~ÒeBBÎ^~, YÈ¥ëY¬fÑn¶¸ôœoâq¾8711Ê3”}ã7Zxòñ<Þ w°6¶tÁ†Å;ZÅ,Æ9 ¢’rAD¦„4VÀeaß}÷í••´Á( lv,_®é†Ìâ×YÜz7è}–õ¤Kû h)Ûà=L`Ôóe¿å$Ì9§³lSO¿ŒZ§ô êŒ%vÚ—úžsÎ9}˜Ó‡Ù4Ç<âvñî©ãŸîsåKÂh­ÓOÉA ^8c>¼ß(±ÄeD)&tW­‡wo¬ŽyŸ¼‹÷¾t‡æ¹ßÝ6Ç™»¶ï»@˜SGreÄõ¬Íñ @ÈFê`“ Ø!P á-}»B䌲`‘H\ÞïØr¥ „yÕq§nuãvç6ûÖ¤B”º¸¶¿Ml(sûCŠe›ëÑ4/gì:Š0gŽ9à€zp{†1Š5^¡íþ`eFÑÔêcW”ÓÀ’„8¬3R…Q'ËÖªŒÍ¦Té}J“-r®wO¾X„ù$}±Í¾4ãJÒ ôQLy$Ì«Œ/x¥c\OÇnæö¬ÁñF…ìÅ &ØgÚ¾»kûÞIö±ñ>ÚQ2ПXbi&ìoâ0I~<Ÿsï<¯ûæ*„9²ô]áé žöl]c×=öØcÀh"n»ïZ?¥\é;W¶æª*$½:2ÂIâóLîP¶×û!>éß)§œRp>/Š<ØZt^s°kký–s<±6Î!‡ìÒübõjû*¼m„»•>ï´ÍG\ñ‚\%`(?Çý8ã"K—5Yú,Æ¢m¤iyê*@`AæŸúÔ§á éàϱhYHd³Ð¶ ·Ò)Á6ð`ô–é"— Ö»hpÆÍ4ˇ+D7‹£4`©bñhа&~õ«_Ý‹ÏsþlÓ>WÔñ³qÚÄ…òç£ ãùˆ+j+W\pûstKÓ†@ãbYÖZk­¾xþœ÷hX„Çi¡‘Wê,†i ÜÒÇéb5ŸZcÇù°ñ >ähY;Åq«Þç$Ìi#Ž}_(oÜ×!·Lø‹V<Êe¥ å1>7‡ªD3ÏäÌ×HGÓhGcØ;ŠÐ:®ïwJ¬×©u!Ž;ˆÓF˜ÇïWÎw·q†ºM+t…0§-9¢‚c#L&nWî™/pEÌxÁ¸V'¤vžeü¶cA,/6¶ŸýìgK“f¬1ò†M0ž7,t0¯2îXyÛºvç6ûV™…y~^B›Ø€AûCÚ6ÓXZž6ÎØ5VÎd-„e ’¬çPî„°¸\Y \~ùåÓ–~ÓkÛýÁʇ¢d¬PJÝ‹Óu›m6âÚ 7³1Ü¿á o°d{W[#B˜ÄÇ¿X„œë]KsØu^óÜ}±Í¾4ãÊ°þ ï…@›t•0Ï5¾p|T:°'Æ@€yrõÕWK—. Wl»¼ïeœ¬²¥f]NýËd4ÔŸ}{(Ⱥ²P5?{¶½ó¼í›SY"ïV丮Æ3 Öþ¬×?¤ÇÇ°fCÑ:ö¤iئ׮öÓÜë¥:2B0ª?Å5Çç²½²/¼m¦x?DÖšÊæ‰0oký–{<¡œ(å’CÎz~ÉÑW«¦!¼*R #Þ¤„9¼YºæBnR%¤y’ÎE]¸¸ÜiV)â,æž0Ç54°¼(¸UŽIkFâl»í¶}/(B³a.í¹ôÊæñ 9ÌR:%8móeiBÐÄ a¬a (F64qþÏ>ûìÒG8×9Ž;Ìz›‡¨â¸œ ÍB»,°ÉŠ•°\/³ \²dI/M\—)@bÇù®»îºeYÖ^Ü2iÛ&Ÿô!Æ—HVÓçŒÊ\!'aN™ ýc¬¸¿êª«zÅeÂ0Að:ë¬Øè—ým±Å}iî×,Ô!šsæ‹F¦YȳAÇS°€Ð2”:Ó9wÞÜYÛ3uêaÏàî=ƹŒ0oûÝÍ9ÎX½¦uí aN}Ùø@¤àÒßÜéÆmk÷ŒO̸õªÊìeÊ:ä¥{|„å÷óZ‚€+] Ì)ϸq'.s÷]Ź­¾U&D™'Âœ>Ð6¤ÝÕþ@ÙÓ\’ŸavåH"Öº;î¸cð–òŠW¼"¬Ÿá=0ÅŠCŒ;(QâU%U¢$Ýœ¡Íþ`ådî/ó(’ºy3k9P&à8D ?®(Àa=g5” X{•…œëݲôãïæ…0o£/¶Õ—º>®Äí¯{!0Ml/L³ äÑÜç_¥i³¯ãr®„.ï{)_•},õŽ×¬Ê<Í óÁs ‡…*ùñl›{çyÚ7§„9ý½Ä(k ú6r+ë—¬ß0(yÿûß_à /FUBWûiîõR]¼nü*X×S¶×ƒßtÓMþX«#£H]æ‰0ŸÜë·6Æ“ÜrÈYÏ/uûe“ø"Ì› 7ϦäuU óô9æ¹óÏ?¿?þñ{ó¢Ígžyfð`aŸíÚ4ÍJR¤EƒÀÜæ,ÀåÒ+{‰ìÊÂÄ6@UZóSü~娗¿üå¡,ä› @ºB˜w¨K›¡«8[s÷­2!ʼæmaCº]ïÓ\‚‡1ñ•õ Ê”±À•ßQ.c]Â8ˆ õ–[n)Uä!Ý6Bîw%-#Z1Üc…hÊJä&¨f|eí ´ÕV[ <‡KL \pAK摲s½[–~üݼæàßV_ÌÝ—º>®Äí¯{!0Ml=Û5Â<×ø‚l"79Œ ]Þ÷Rî*ûXÚ3ö8C;3²oNåb¸ÌŽå )6Uòã™6÷Îó´o¶uˆõ;öˆozÓ›Š]vÙeÀSqpÏQ=ôÐ@Û¤mîj?ͽ^ª+#¬?Æ4×}Ù^ÅÖåeÈ8B/¦ä9o„¹a—kýÖÆx’[9ëùÅ0ŸÆU„ù4PîN)ñ]•0/#½«Ê^‘ûÛ¼iW¼ÿ´‘fwVIº€ÀÜæ,0yi ØFmr~øážËj{É8§{Ô& m : rHgˇ+g,ÄáU¯zUßïÃ,Åãg¸Ç’6NËɲP‡0§lqšãóT“÷i€âL ,ËYZÀÅö•W^ÎØ6Ï–7Jea’Å-îÊÍz“ôîsŸHþu¯{]¨;ä² V"MðENÂâØ¬Ç +®÷z—öpj¿­°Â ¡¯#,®ú»c«C4çÌ7¶ÆEu•Àbt˜ §N=,¯*ÿ¶ßÝœãŒÕkZ×.æÔÖé¸cï WÆ Ôº¤ »avÞU¼…ÄirŸž§ËÆ×6½Çü@] Ì«Œ;ÏüEWqŽ«™³o• Qæ•0£œØ^×ûÃ4×£à‘Ž3Ç‚U5®Æ9óá®Ç9¡7çý1ŽSF#í6Bîþ—«ðØkØ ‰Å ¯Ø;ž>ì{»â2ÔÖƒ›o¾yøå¹2V¤s½Kz£Â¼æm÷Åœ}©ëãʨþ ß„@›t•0Ï5¾”ÃŽ3œ»¼ï¥ŒUö±Ä³£FlÞCÑ™Á»Þõ®>¯€x¡§a¡j~mîçißœæ(&#+ãï€Xà¢û+_ùÊ0ø‡~ßÕ~š{½TWFX7þP€ü0é^ïŠ&žWÂØr¬ßÚOrË!g=¿4袵a^²¹~`RÂ<YTåÀP&²õŠ]¿ô¥/ VæHs®G…ÏŽÀ\æœác²X"¬õ‡å­½`veÃP5ÔYcÑlypM sܞǿ²ŽË÷á¸ï96³h륡ažž¹>Ž0O­ç™$ÇÈO|âÁòlp1•žÉž“0Ç}nŒbŒ±èŒÉU,ŽÐˆ"nés†œ„9‚à¸ÜÓßÍþï~÷»>å6\(‚Ôù U‰æœùR—ø RÜ­7 UëçSeãßö»›sœ‰ë6û®æVwahj£™lï~ún­±Æ#•¯Hk˜€ß8'7µîÄÅÖç°& _Üï¡X”†.æãÆ´Ìm|î*ÎeuÍÑ·&¢”•§KßåÀ†út¹?L{= éØ©‹· ,‘|ðÁpÞ6$¯‘¿<Ó…«?ÄuA›½>Îm°Á¯•W^¹oÍ ^(ÆXB´³fÇe;c7¿zè¡qv#wG&ìœÂ|Z}1G_êò¸2®?èw!Ð&]%Ìs/u ®ï{é Uö±Äã|ÝÔ¸ƒ¹eæK<­àÙp\¨š_›{çyÚ7§„9?î»ï¾"%iÊŒSì¹ô:ýÔÊÜt½”0Xì uãJkÒßšìõ0¢OL‹0Gáv”l=þíÆo¬I“õ[îñ¤ 9ä,ç—Z ‘!²ó ÎQ“æ(ìÇŒeùÈG*Õ<å«x–½ziV*"-æš0Ç‚†—ÅþØØú³xñý§?ýi¥ϵ Gxgnä­,GuT¥2`%mÏصì|ð®æœÿˆ•îï9×÷¼ç=ÁÊB×êÀ5'a˜œQ§æW_}uçsÏ=7üŽv/Âåœ!'aŽÅk\î7Þxã ¦Ì÷zKóø÷#Ž8¢QUªÍ9óe“×e‡¦¡j=â|Æmü§ñîægâzMë¾ë„¹áðÀKò²3º9×RbT%`‡ 2r&îÓ{íµWH’ñÚÈúw¼ã½÷8ί „ù¸q'.o[÷]ÅyT}›ô­&B”QeêÊoM°¡]îÓ^‚G<¾pKÇy MûCZ×2kñå—_>‰a=p¹˜ÜÔ§Xr^9Öú|ÏœpóÍ7§ |αÞH4ùb^ói÷Å&}©ËãJÒüú(¦Š@W ó\ãK]B£ëû^:Ǹ}¬u ‰¤6bÙŒ;pã£B•üÚÞ;ÏÓ¾yaÎ(u§žQ†HFµÉ<ôÓ\륺xÝø£pžô·&{=<¦â…Ùj0)Á…ljQ²õø·K.¹¤N‘zqë®ßÚOÚCÎr~é;¥æSº#ÙL:žPüt~;üðÃ+Õ kr[ŸØ¯ym¥Y©PŠ´(˜[Âœƒi—½øÅ/ÖX€Œû{ÉK^2ð²}ôÑ•;ׂœ‰ ^{Ù¹Vµt/Ó®ùå/9Pþ.æhýl½õÖÅJ+­,.·ß~ûàôþûï.,Y,Çä&Ìé#k¯½v_±åòf›m~Û}÷ÝKI«Pk|‘“0ýë_ßW0Ck!=»ƒ n“P•hΙošš†ªõˆó·ñŸÆ»›kœ‰ë5­ûYæXB°˜2Ï ãêŒfó—¿üåB%‡¸Çmû¨0JÀÎs^xá@š(ga±ÈÂ<ðÁ¹te¡ „ù¸q§¬Ü¹¿ë ÎÓê[M„(¹±¯šÞ´°¡<]é)6³XR†tÜÊE"¤õ«óyšý!-kÊtáiqéÒ¥Eº¿5ÜW[mµ¾c¥âç«æ—¦Sî5Oûæq„9Øâ© ¯E±l‡¶@nÅz„6Ò¾Õ¥~š{½T—¯Γþ–{¯W¥“\W\qEqÜqÇUú»ýöÛ{Ei{ý–{êèÎÿ‹û3÷(¿6ãÁ(EYæUÇaØäü¾+8O«oå¢0"XF+·­0-l(WúCŒå¬Ö£”!_r‘qýêÞO³?”• ‘ûü| ì‘ðÝÉ'Ÿ\úcõ0O <˜{½;´€ÿûÃb"̧՗º8®Œëú]Læý(w}ßKi«ìc©ÇÖaj}ûÍ÷¿ÿýÁ3 Í›v}÷»ßmQû®Uòã6÷Îó´o®B˜ƒî×wÜqÇu ä÷8Åð®öÓ6ÖKu ðºñi‹Ü!÷^¯Jù&%¸0Ày衇*ý™µ'åi{ý–{£íõ[ãIn9ä¬ç—ÁViïæíaÛÅ”›Œ'|a¸zçwŽ¬&ûðøÈ5<,ßu×]½gÚH³—¸n=sG˜³q Fˆ‘[n¹¥v#bI›‘l ¯ºêª‘iå\ó’ÇVÁÔg‡v™??r·-œ)3daY˜%a‰oe䟗•Á1Ž‰]š.nñ‹_ôÜ Çù!@Û²¼'ýnÕUWí«[ súøg>ó™Oœ{Ï÷üž†´½ó˜ÇÇ|i\{²œ³‰èGï}ï{{qS -6ÕÃBÎ|;ì°>ÌP"ÁòâqX¸çž{ 4ÎhËoûÛ}ÑêÔÃLb×qã‘•;½ÎkHëaŸ:è l6ÝtÓ‘JPh·o¿ýöÏsÇž{½kuv¥<ÖÞv=ï¼ó†Eø>g[[â9û¢¥ÉuZcK×Æ•Ý Y"м­ñ\'!4º¼ï¥NUö±Œ­Ìûï¿? †!dc9îÀËäUò#ƒ6÷Îmì›Û˜+Á#¿lîæŠÆa¼‘MÆí`Ï®¿þúŠ~ÃBûi륺2ºñÛèXÚ[;ÚuœÜaX;Wý¾ ÁU58^Ûë·6Æ“TfÓT9ëù%n¶ïE˜·p·Òo:ž¤{Y`F¼ÈÂ¥ØxÉ™å©aSiŽ*“~[<ÌaΠâæ¥/}éHËaÍÈÔ, ìÅ㊥-îP†Î:ãr•œZ¸¤d/yúbCˆŽÒ°|žÐ+Ã’%K†Zŧ®j°ª([\¯a–Þö|ŠdIvÛm·¾ô°†œ8uÔQ}ñp‹\î¿ÿþ¾xbuíÍù;q¹ß|óÍÛ:鎊›phOUq7ÂB«wˆ¯Ø] ¤ÞX€–4¼!ã:RÒzðÁÁ û®»îZp:Öå授´gœqâ|YrÞ!g¾ôýX{Œ2𮣠C>M,ðþ|ík_ ï,ýa=ö(R²®N=,Ýk®¹¦¯îôÝ4´ýî¦ïW“q&-{ÛŸgI˜óžÓ^ôÞ·­¶Úªà}À7öˆÁó§œrÊÈÇLsoé‚-~0³I2?ãg¸‡Ü!nüWÅÝþ´Ç¶x?ñB±‹e|b?­ï°Ï]ÁyZ}‹q8nsîë Q Ç÷×yyÊo!w›M Êß•þ`XÎr=Ê’öŽ(ªæ¹? «+‚æ€ÎgpQ?CÔR-­Üë]KwØõÀì+#åemX%änkË3W_´ôì:­±¥kãŠÕ_W!0kº@˜·5¾€-ûÆxÌç‚lTèò¾—rWÙÇaþ¬g=«àx¼²ÀøkÊDà‚EXY¨’ϵ¹wνonk®ÓG=êQ}}‡QÙ °és|ÆeûÃ?\úxûi륺2Â:ñÛê(:¤ãÎ(ã”Ò®ùå7¿ù;<‘'·Ú^¿µ1žä–CÎz~i³}Ó´E˜§ˆ,ìÏMÇä£+¬°BoLBÖËùSôöÞ{ï^\æ>òOCi¦yèóâD`®s&H[dìµ×^·ÚùçŸßKÇÒÃk˜ëR&þ˜¬æ™ôÌd+ „"ä·¥Ëõ²Ë.³Ÿ{×_þò—çíÆñØœ”YÔâjk`‹‹ á;—Vz“Z(sÌ1i”Þgλ¶t¹RöQ$PêN*u%衇ö¥ÇÀ¶Ï>û×R÷Þ{o8×B?%w >©W|~õÍ7ßÜ—D2îŒê°fcד>ÐF€°HÉkÊL=Ê®Ñpë nœ‰œ’Æ´5.7G‘lL2(PÄõãž´PÁ]ùYgUpÞÇÛßþö@pAÂÓÖ]tQ¡‚E~œÎÿoï^Bå(þŽWиŠ"1‚rq¡ ‚+•øÚ¨D""‚fñ׊F "¢t³ˆ"Añ‚`Ü(ñ‚! å^E|,"A—έoÝ[‡NOÏëL÷L÷Ì·!™9óè®þTMuUýª»4ÎƒÍ $0CøŠ+®H—|¯s»L(xôÑGÙ6é \0 ¹iÓ¦%î¡Æ Ð[n¹eé‚ .HH‚´UMÆÙœ/¯¿þú1Ûï÷[hê·ÛD=“÷m³ ˜³ÜŠ —]ÊÍ­·Þ:0€Ëd~ù;<^sÍ5K¿ÿþ{_®ŸþyyÒuÛ ËâQ¦Ë³ü‹÷Ü©ÚõAեܟþùª/¿6‹zçž{î9f‡ÁU®ø0ný¼¼…'msžFÙâL’bYäù™gž9t6Ž\î6DñR¾íHy6 ›¶•‡Y¶GÉoêrYaàµj‚Ÿï·tµ<ôÛ^'oŠmk®(UÕ®.¯ƒß“²+dzAx¾_w{·œ¦òßLôÌéËwß}wùc•7‘×l¨®²X•è¦ë–¶Õ+U¾¦À¬Ú0o²~á¸ëÑü8ìêTmî÷RNFéÇæ€9gl•ÛˆÅ²V¼‡öÖ­[‹o-?e{ùÃMô›è77u¬¤lår–Ê'!d§ò#g$Çów·$­U“<ÚXN›h/;F8Îç›*Œ ç<Ìœœ2hœ¯\&ÆýûÅ_2@öÅ_ô¬’ì⥠øÎÃ?\ÙØ óPþ, ]éååƒ>Hgæå4Ð9%ðÉ%®ô£#@CšŽJ¾Œüù矿Äå¦y¯jùå—_Ò {^'1ªþx`vñ³¤ý7Þ¨Zõé%HTü<¡âý²«>Ã%¨¸ß/g»‘~‚µ ì—/M…?—™"`ÄB…xÿý÷³=¶Í=ŠûíeÂã‹<òÈòzÖ­[·Ä=Ôë^8CËÏÏVâž~úéTöžzê©Æîºë®K÷¨*_r‹KÔoÛ¶-•Ç¢o¿4s{lóöò#iá@ó_ñŒC‚/ù äÁž={z‚[” .Ež¿Ï#WàìQkI'gtç†v]Ûe¿˜ù[œÑ^L{ØLØȃ8Ì*g’EUYw?˜¥}ÓM7³ßü8ë¬jiâ·ÛT=S•þ&^›uÀ¼\—QƹÉ®]»Ò•&Qn$óÍ7Óo/—%ÊuÔ7ß|SIÃ÷x¯|uîÍ1#ÿÊ_æ÷‘'Ðp :xýÒ·sçΞ:–´± rü*/³ªwŠA©ü[¥Îñi¥K[›,[Ô_ âpŒÈŽù‘«pÿC=”6¹ÕÊøÇUj¶oßžêc®JÀÕ ÊÇg.›U\šÈ³&mÚXfÙ¥¬0Aìæ›oî)+ë™TV¼bL1ï«žw­tõ½¦Ò×tý‰O<ñDO}Ê1€cü ¥­ýÞQû±9`Î1„³¼¸jyœaÿþýKŒ•ð.y~ðàÁ’Q·WübÝ}ç&úÍu+ÙÎ~ã6sù¸]|äì¹ü±ÈÔóü¿ã 'å{,³Úœ¹ÍÕ½Êýж•ÓºÛK㎎ûùºËuùĘl1ÿyÎ ôŠ_àj{—]vÙ1Û¤¿Ðï$±W;ôcMµßŠ®»>©k²-Ç—¢U“Ï ˜7©Û®u×UŸp¢'PR÷Q{àê±Åå»ï¾K'éåúrãÆoEÒÄ:‹éñùb t"`¾wïÞÔ¸(éÈqv Á»o¿ývh2så7Þ˜.y|ÅG~´œÍʬž¹ .ÁjÎf-~Žçùgï²pisãå`#ŸåE Úq–oq!ˆÎ¥£ÙFî˜äÉgÔr94ˆ ÞqÆ$iª ~¤`𜳔så“ÓÌÌEÖEИ®trxN”´åÏåGö}É÷”xë­·’Ý…^ØóYÎf#ÐÈ,ef¹²nò¤*hÌú üs–0/ÎÎÛÌèT<øàƒéž’Ué£óÆg°uÒħŸ~º¼-ÊA “$ð¥"/΂ÊûÄ#ùK™á &ήg¿ÈëœWä/`Lž}öÙtƒq¾é(qÕÒÑÏ>§‡Ë'sÖxÕ¬d\žyæ™åtåïc½ü~:´ÌWçvY)傼ÏAƼýâ#V¤ƒk¹ƒ¸œ°ød”ý`Lr¸þúë+£ Bq@/ϯó·Ût=S4iòù¬æÆ)' É·\§ò{ã²áÔ%t ŽËÁE™ ÂD¥ªÀ \˜ÈAКßl±,²\_3!¦¼PN(«|‡`VÕú93˜:”ôT/®??ç÷GçúN5ˬëfyæôݤìSü»­Î¤±©²Åˆs9ªâ„À¢'å“öÇZÊœüãoŽ§ý¾Çgè´—ºó¬I›6–‡Y¶G_{íµ¥n¸!M*,O6Ìå… e´C¨O˜|3léRy¶/Å÷|Îmˆwß}·øÖÀç úо ­Óïª@ÅÔÑÞÍ}ˆâzósÚ'ôèë”ïÓšóœ´2Y’AXú}ôQþú1uæueñ˜ÄþÿMÔ»m¬WªöÝטµ@nCO;`ÞdýBŸ‘0hKÓ'Ïõh~¤O~!móª¥mýÞqû±Å€9ûͤ+Î&ç*oŒ?ÐWáêv¼Çä}Še`Üí ëê;7Ùo®óXùöÛo/qÕÇ<–—ËYñ‘1¾K/½4}.»ÍòsƱª®@–'‡oÞ¼9MÏŸo[9­«½Ä˜ï8c„ã~>ûÕYèë‘?Œ#ôë³1.xùå—§öûK/½”“±¢GÆ™D=Æ„êÜ.–;ÚL¶`<˜vQÝKí·rëªOŠëd²Ç—â¾5õÜ€yS²íXoSõ ɘàÎ1¾,ñ¶ûî»/µC¨—8‘‰¸c ŒÅ—o\¥ÓÄ:«¶ãk‹#°Š]ÏV/ñ¬ŠƒÁ÷{Ò\!^†2ÄlˆgÐö¼_|!ÌC 4„l±á_|«çyüa†xßëï3Ø~läõ|†bg2Äìƒi)ñlÔÏéûÙxV|ˆ °ž÷cp>Ä€{øðÃC¤ ñìçºC¬@B¼|ˆ¨/ƒ.¾øâa%…¹IDATÏö ìwy‰—õñ,“À~VYÅ 'ÄÀyˆæƒE!ž!Ÿ>åU¥¿×¬Yb )Ä +°_±ƒb'«ò³¬;ܧϒæXY…Ì q 2ÄY±É;ÎTñìñϨ1Àø;vxÒwâ ¢”1ÈbG5œ{î¹!vÐBœåÝ7¯È÷x¶tˆ—›±³P™®â‹ñH!v“] ,§´ߟä9û'ôMkÕº)có»Ø) 1(’žÇQˆâU_øùÏ> ï½÷^ˆ³XC4Nyƒtuò/|RY¢ ôs‹gº†x è”ü(çñþÐ)ïâ€}*?ńԵݼÎ8Ã6ÄY£!ž™ö‡}Š³ßS⤂”þØ©q9ÄÁíüµžÇQöƒßÍ;３~ãñìÝžuðBìܤüˆÿž÷ëøíÆ{M¥žéI|Í/Ä–g´‡x߯°aÆš×>|uq¶t |ÆYÍ!vS=Jzâ}ÊC<;<Ä™‡©±&êŽP ëׯq0#P7ÇÎcˆXz6Äoºªª^ͦNŽízù¥åGêÖA]ÊöÊ õ6uì°ãßc;qÒMˆÁ°T¿Î²Þ‰Êð /$_ŽW³<÷Üs!^&8=翶:³M–­8¨£ë^8žÒæ).uçënÒ¦m¿;~¿³jÆŽbjgô;Nó9N²HÇGÚƃ–.•‡AûQ~º4Nr ñ M·QÛSôâàbjëÆ T©íS^wùïIÛ»âä—òjÓß”µ< ýÚéå/ÑVÛ²eK }T^êÌkÚÓ{ê,‹åôòwuK›3U¾¦À¬beyÌdP_«îô5Y¿plxà‘#Gú¶»ØWŽqryˆ–*w¯MýÞqû±ÄÉõ©ŸÆX}ìxfe:îÅ€Oraÿcp/Ä i쉲—q·—¿W|œ´ïÜd¿¹Îc%Vñ€#+)w1°b` Hµüœ|‹W€Lc<Ë/žðý'Ÿ|2Kæ—ÛTNISí%ƈb@yä1Â~øa¬Ïç±±:ËíŽQûz´ßãÄ×ðŸ8^»Ò…ñƬ╇R]×oü‚ß5ãŒs1î]çÒDû­_ú&­OÊë]é8d[/åý«ûï¤1°xrJˆW]¬{õ®oÆMÖ'‡NcþÄ.h‹Ä[¤ã%ãbÔKñ–º!žúµÄªb`ež&ÖYÞ†/Ž@'æ½â™°s…`9þA 1‚·£.ihðô,æ³ñLçÀtÐB#Œ MÕ¶8@,'8H§…}"0ÏJßc0¬ßBç mØB šÆ‰Ãéi´Q9‘&ñÃ>ËwXøN¼ôqjÐæJmÇÝËŸa0ÎüLëæ{LÀ’e˜;Ÿ¡Ò$Ðé"}üÎê÷[êØn^7¿ÒÀ:ùÇï— 'éà7ÄóQ–aûÁºGùÝPƘ¬RµLúÛebÈ°ò^W=S•þº^›uÀœc¿m&ÑÀ¢ÞáwÀë}}ÚŒËÐÇà¸Ä¾WõiÆÝ^Þ¿òã$}ç&ûÍu+i/ruáÄ–x¦qß“Gô»ú-Œ¡‘å¥ å4§iÒöÒ(y϶ò!íÀac,ÅÏç1Å:ËÁ¨íŽl4JÝ“?[õ8î˜7' 0žZçÒDûmPú&©OªÖ»’ú¸ÍÇ—ª}¬ë5æuI¶s=M×'üv™´ÇqŠ#¨ó?ÆtóD¦Q…šXç¨Ûösó%Љ€ù|‘»7³ Ñ/óh°îÞ½»ò,ÿY¤Ëm*0O³˜ÓQ!HNÇ/wx˾t€ù\žØS~ß¿W&ÀŒâx?÷4+†ŒÛ°]ÙV§÷­y,[uåÙ<ÚL¯dµgK–‡öäEÓ)©+¯›N§uKÓ®_þ³ ˜÷O‘ï(0]®+§«²x[³ŒŸç¶ßÆ7ëê7 ˜w5çÚ™n&­3NÛo,w%©nb+I‡ß鞀óîå™)^@¼7Oˆ÷,Kg&sP4{w«÷+ (f07f#ÀÕJn¿ýöðÙgŸ¥KÏÿg‚ËÈÍfo«æÙâåù =¶< Ò™¯÷ÌëùÊO÷F¦ ˜7%ëz» à±² ¹Ô|-Í»…n 0ïvþ™zè/`À¼¿ïtP€K†ðN~^¸%÷êâòðÜ·Œà¹‹ Ô/`À¼~Ó¶¯ñË/¿ ;vìH÷ºë®»Âã?ž.¡Ôöt/rú̳EÎýÞ}·<ôšÌë+æõ¼æ¬û¥@ýÌë7uÝðXÙ|j:•–ƒ¦…]ÿ<0Ÿ‡\tP JÀ€y•Š¯uRàý÷ßOg7ro#îµ½~ýú¸yùå—ÃÇœîŵÿþôz'wÐD+Ðræ-Ï š“Ç}ᮺêªtßò­[·†-[¶ ½grÍIpuc ˜gc‚ÍùÇ-sžÁ…Ý3¯ >U@¡̇ù9ðX9‡™º‚]²¬Í¯,¤€ó…ÌvwZ…0`¾Ù¼;yå•W†O>ù$pŠ5kÖ„“O>9œp )˜ÃYç»ví Û¶m ÇwÜb€¸— LYÀ€ù”Ág¼9êÚíÛ·‡7†K.¹$¬]»vÆ)róÃ̳aB‹õ¾åaqòÛ¼^œ¼vO¨CÀ€yŠ®£k+»–cͤ×rÐŒ«k?æó—§î‘ üŸ€sKÂÜœqÆá?þ¨ÜŸ«¯¾:¼úê«á´ÓN«|ßP`ræ“vm ¿þúkºzÇêÕ«»–ô…M¯y¶°Y_¹ã–‡J–¹|ѼžËlu§hDÀ€y#¬®´+;ISH¢å` Èn¢óÌ;Ÿ…î€ ô0`ÞÆ—»'pÛm·…½{÷ö$|Ó¦Má±Ç ó\P 9æÍÙºfP@P@¦!`À|ÊnCP@î 0ïnÞ™r,`À|°ïvHàûï¿ûöí Ÿþyø駟ÂÙgŸ‚ä›7oçw^XµjU‡öƤ*Ð=æÝË3S¬€ ( € ( @QÀ€yQÃç ( € (P0`^ño˜æó’“îG8räHº,ûßÿN:é¤tO]ï«káP`:̧ãìVP@P@hJÀ€yS²®WP@ù0`>ùè^( @¯€ó^_Q@X€ó ùP@P@Z$`À¼E™aRP@h¡€ófŠIR@Z ˜×ÂèJP@ ˜[P@P@趀ón矩W@P iæM »~˜•€óYÉ»]P`Î ˜ÏY†º; ( € ( € '`À|á²ÜV@P`,æcqùaè€óe–IU@Ú,`À¼Í¹cÚP@P@.`À|¸‘ŸP@P`‘ ˜/rî»ï Ì·€óùÎ_÷N˜šÀîÝ»Ão¿ýî½÷Þpúé§Om»nHP@P@êرcGø÷ßÃÎ;êU«êY©kQ@P@¹`ì1À³Î:+Üyçs³_îˆ (`ÀÜ2 € (P‹ÀáÇÃÑ£GÃÚµkÃñÇ_Ë:]‰ ( € ( € LOàÏ?ÿ KKKaݺuÓÛ¨[R@P@Î0öÇàêի駞ڙt›PP`˜€óaB¾¯€ ( € ( € ( € ( € ( € ( € (0—Ìç2[Ý)P@P@P@P@P@P@P@ȧ ù¾ ( € ( € ( € ( € ( € ( € ( À\ 0ŸËlu§P@P@P@P@P@P@P@† 0&äû ( € ( € ( € ( € ( € ( € ( €s)`À|.³ÕR@P@P@P@P@P@P@&0vÀü¯¿þ G¶^ßW@P@P@P@P@P@P@P 1Õ«W‡SN9e¢õ0¿ãŽ;¡C‡&Ú¨_V@P@P@P@P@P@P@P`sÎ9'ìÙ³g’U„±æ]tQøúë¯'Ú¨_V@P@P@P@P@P@P@P`b×_}õÕ$«0`>‘ž_V@P@P@P@P@P@P@˜‰ÀLæ×^{m8xðàLvØ* € ( € ( € ( € ( € ( € ( € (€À† ¾}û&Âû’ìÿüóÏDõË ( € ( € ( € ( € ( € ( € ( € L"pâ‰'Î2Ÿd;`>ÉÆü® ( € ( € ( € ( € ( € ( € ( €m0`Þ–œ0 ( € ( € ( € ( € ( € ( € ( €S0`>Un7¦€ ( € ( € ( € ( € ( € ( € (ÐæmÉ Ó¡€ ( € ( € ( € ( € ( € ( € (0UæSåvc ( € ( € ( € ( € ( € ( € ( €m0`Þ–œ0 ( € ( € ( € ( € ( € ( € ( €S0`>Un7¦€ ( € ( € ( € ( € ( € ( € (ÐæmÉ Ó¡€ ( € ( € ( € ( € ( € ( € (0UæSåvc ( € ( € ( € ( € ( € ( € ( €m0`Þ–œ0 ( € ( € ( € ( € ( € ( € ( €S0`>Un7¦€ ( € ( € ( € ( € ( € ( € (ÐæmÉ Ó¡€ ( € ( € ( € ( € ( € ( € (0UÿjûHbpQøIEND®B`‚library/requirements.txt000066400000000000000000000002721443355502200160120ustar00rootroot00000000000000einops==0.4.0 matplotlib==3.7.0 numpy==1.23.5 pandas==1.5.3 patool==1.12 reformer-pytorch==1.4.4 scikit-learn==1.2.2 scipy==1.10.1 sktime==0.16.1 sympy==1.11.1 torch==1.7.1 tqdm==4.64.1 library/run.py000066400000000000000000000211331443355502200137030ustar00rootroot00000000000000import argparse import os import torch from exp.exp_long_term_forecasting import Exp_Long_Term_Forecast from exp.exp_imputation import Exp_Imputation from exp.exp_short_term_forecasting import Exp_Short_Term_Forecast from exp.exp_anomaly_detection import Exp_Anomaly_Detection from exp.exp_classification import Exp_Classification import random import numpy as np if __name__ == '__main__': fix_seed = 2021 random.seed(fix_seed) torch.manual_seed(fix_seed) np.random.seed(fix_seed) parser = argparse.ArgumentParser(description='TimesNet') # basic config parser.add_argument('--task_name', type=str, required=True, default='long_term_forecast', help='task name, options:[long_term_forecast, short_term_forecast, imputation, classification, anomaly_detection]') parser.add_argument('--is_training', type=int, required=True, default=1, help='status') parser.add_argument('--model_id', type=str, required=True, default='test', help='model id') parser.add_argument('--model', type=str, required=True, default='Autoformer', help='model name, options: [Autoformer, Transformer, TimesNet]') # data loader parser.add_argument('--data', type=str, required=True, default='ETTm1', help='dataset type') parser.add_argument('--root_path', type=str, default='./data/ETT/', help='root path of the data file') parser.add_argument('--data_path', type=str, default='ETTh1.csv', help='data file') parser.add_argument('--features', type=str, default='M', help='forecasting task, options:[M, S, MS]; M:multivariate predict multivariate, S:univariate predict univariate, MS:multivariate predict univariate') parser.add_argument('--target', type=str, default='OT', help='target feature in S or MS task') parser.add_argument('--freq', type=str, default='h', help='freq for time features encoding, options:[s:secondly, t:minutely, h:hourly, d:daily, b:business days, w:weekly, m:monthly], you can also use more detailed freq like 15min or 3h') parser.add_argument('--checkpoints', type=str, default='./checkpoints/', help='location of model checkpoints') # forecasting task parser.add_argument('--seq_len', type=int, default=96, help='input sequence length') parser.add_argument('--label_len', type=int, default=48, help='start token length') parser.add_argument('--pred_len', type=int, default=96, help='prediction sequence length') parser.add_argument('--seasonal_patterns', type=str, default='Monthly', help='subset for M4') # inputation task parser.add_argument('--mask_rate', type=float, default=0.25, help='mask ratio') # anomaly detection task parser.add_argument('--anomaly_ratio', type=float, default=0.25, help='prior anomaly ratio (%)') # model define parser.add_argument('--top_k', type=int, default=5, help='for TimesBlock') parser.add_argument('--num_kernels', type=int, default=6, help='for Inception') parser.add_argument('--enc_in', type=int, default=7, help='encoder input size') parser.add_argument('--dec_in', type=int, default=7, help='decoder input size') parser.add_argument('--c_out', type=int, default=7, help='output size') parser.add_argument('--d_model', type=int, default=512, help='dimension of model') parser.add_argument('--n_heads', type=int, default=8, help='num of heads') parser.add_argument('--e_layers', type=int, default=2, help='num of encoder layers') parser.add_argument('--d_layers', type=int, default=1, help='num of decoder layers') parser.add_argument('--d_ff', type=int, default=2048, help='dimension of fcn') parser.add_argument('--moving_avg', type=int, default=25, help='window size of moving average') parser.add_argument('--factor', type=int, default=1, help='attn factor') parser.add_argument('--distil', action='store_false', help='whether to use distilling in encoder, using this argument means not using distilling', default=True) parser.add_argument('--dropout', type=float, default=0.1, help='dropout') parser.add_argument('--embed', type=str, default='timeF', help='time features encoding, options:[timeF, fixed, learned]') parser.add_argument('--activation', type=str, default='gelu', help='activation') parser.add_argument('--output_attention', action='store_true', help='whether to output attention in ecoder') # optimization parser.add_argument('--num_workers', type=int, default=10, help='data loader num workers') parser.add_argument('--itr', type=int, default=1, help='experiments times') parser.add_argument('--train_epochs', type=int, default=10, help='train epochs') parser.add_argument('--batch_size', type=int, default=32, help='batch size of train input data') parser.add_argument('--patience', type=int, default=3, help='early stopping patience') parser.add_argument('--learning_rate', type=float, default=0.0001, help='optimizer learning rate') parser.add_argument('--des', type=str, default='test', help='exp description') parser.add_argument('--loss', type=str, default='MSE', help='loss function') parser.add_argument('--lradj', type=str, default='type1', help='adjust learning rate') parser.add_argument('--use_amp', action='store_true', help='use automatic mixed precision training', default=False) # GPU parser.add_argument('--use_gpu', type=bool, default=True, help='use gpu') parser.add_argument('--gpu', type=int, default=0, help='gpu') parser.add_argument('--use_multi_gpu', action='store_true', help='use multiple gpus', default=False) parser.add_argument('--devices', type=str, default='0,1,2,3', help='device ids of multile gpus') # de-stationary projector params parser.add_argument('--p_hidden_dims', type=int, nargs='+', default=[128, 128], help='hidden layer dimensions of projector (List)') parser.add_argument('--p_hidden_layers', type=int, default=2, help='number of hidden layers in projector') args = parser.parse_args() args.use_gpu = True if torch.cuda.is_available() and args.use_gpu else False if args.use_gpu and args.use_multi_gpu: args.devices = args.devices.replace(' ', '') device_ids = args.devices.split(',') args.device_ids = [int(id_) for id_ in device_ids] args.gpu = args.device_ids[0] print('Args in experiment:') print(args) if args.task_name == 'long_term_forecast': Exp = Exp_Long_Term_Forecast elif args.task_name == 'short_term_forecast': Exp = Exp_Short_Term_Forecast elif args.task_name == 'imputation': Exp = Exp_Imputation elif args.task_name == 'anomaly_detection': Exp = Exp_Anomaly_Detection elif args.task_name == 'classification': Exp = Exp_Classification else: Exp = Exp_Long_Term_Forecast if args.is_training: for ii in range(args.itr): # setting record of experiments setting = '{}_{}_{}_{}_ft{}_sl{}_ll{}_pl{}_dm{}_nh{}_el{}_dl{}_df{}_fc{}_eb{}_dt{}_{}_{}'.format( args.task_name, args.model_id, args.model, args.data, args.features, args.seq_len, args.label_len, args.pred_len, args.d_model, args.n_heads, args.e_layers, args.d_layers, args.d_ff, args.factor, args.embed, args.distil, args.des, ii) exp = Exp(args) # set experiments print('>>>>>>>start training : {}>>>>>>>>>>>>>>>>>>>>>>>>>>'.format(setting)) exp.train(setting) print('>>>>>>>testing : {}<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<'.format(setting)) exp.test(setting) torch.cuda.empty_cache() else: ii = 0 setting = '{}_{}_{}_{}_ft{}_sl{}_ll{}_pl{}_dm{}_nh{}_el{}_dl{}_df{}_fc{}_eb{}_dt{}_{}_{}'.format( args.task_name, args.model_id, args.model, args.data, args.features, args.seq_len, args.label_len, args.pred_len, args.d_model, args.n_heads, args.e_layers, args.d_layers, args.d_ff, args.factor, args.embed, args.distil, args.des, ii) exp = Exp(args) # set experiments print('>>>>>>>testing : {}<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<'.format(setting)) exp.test(setting, test=1) torch.cuda.empty_cache() library/scripts/000077500000000000000000000000001443355502200142145ustar00rootroot00000000000000library/scripts/anomaly_detection/000077500000000000000000000000001443355502200177125ustar00rootroot00000000000000library/scripts/anomaly_detection/MSL/000077500000000000000000000000001443355502200203455ustar00rootroot00000000000000library/scripts/anomaly_detection/MSL/Autoformer.sh000066400000000000000000000006021443355502200230220ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model Autoformer \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/Crossformer.sh000066400000000000000000000006031443355502200232040ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model Crossformer \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/DLinear.sh000066400000000000000000000006011443355502200222140ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model DLinear \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 100 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/ETSformer.sh000066400000000000000000000006241443355502200225510ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model ETSformer \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 100 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --d_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/FEDformer.sh000066400000000000000000000006011443355502200225070ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model FEDformer \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/FiLM.sh000066400000000000000000000005751443355502200214770ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model FiLM \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 100 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 32 \ --train_epochs 10library/scripts/anomaly_detection/MSL/Informer.sh000066400000000000000000000006001443355502200224560ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model Informer \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/LightTS.sh000066400000000000000000000005771443355502200222300ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model LightTS \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/MICN.sh000066400000000000000000000005741443355502200214350ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model MICN \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/Pyraformer.sh000066400000000000000000000006021443355502200230250ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model Pyraformer \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/Reformer.sh000066400000000000000000000006001443355502200224560ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model Reformer \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/MSL/TimesNet.sh000066400000000000000000000006121443355502200224300ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model TimesNet \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 8 \ --d_ff 16 \ --e_layers 1 \ --enc_in 55 \ --c_out 55 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 1library/scripts/anomaly_detection/MSL/Transformer.sh000066400000000000000000000006031443355502200232020ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/MSL \ --model_id MSL \ --model Transformer \ --data MSL \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 55 \ --c_out 55 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/PSM/000077500000000000000000000000001443355502200203515ustar00rootroot00000000000000library/scripts/anomaly_detection/PSM/Autoformer.sh000066400000000000000000000006011443355502200230250ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/PSM \ --model_id PSM \ --model Autoformer \ --data PSM \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 25 \ --c_out 25 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/anomaly_detection/PSM/DLinear.sh000066400000000000000000000006001443355502200222170ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/PSM \ --model_id PSM \ --model DLinear \ --data PSM \ --features M \ --seq_len 100 \ --pred_len 100 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 25 \ --c_out 25 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/anomaly_detection/PSM/TimesNet.sh000066400000000000000000000006131443355502200224350ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/PSM \ --model_id PSM \ --model TimesNet \ --data PSM \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 64 \ --d_ff 64 \ --e_layers 2 \ --enc_in 25 \ --c_out 25 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/anomaly_detection/PSM/Transformer.sh000066400000000000000000000006021443355502200232050ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/PSM \ --model_id PSM \ --model Transformer \ --data PSM \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 25 \ --c_out 25 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/anomaly_detection/SMAP/000077500000000000000000000000001443355502200204525ustar00rootroot00000000000000library/scripts/anomaly_detection/SMAP/Autoformer.sh000066400000000000000000000006041443355502200231310ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SMAP \ --model_id SMAP \ --model Autoformer \ --data SMAP \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 25 \ --c_out 25 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/anomaly_detection/SMAP/TimesNet.sh000066400000000000000000000006201443355502200225340ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SMAP \ --model_id SMAP \ --model TimesNet \ --data SMAP \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 25 \ --c_out 25 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/anomaly_detection/SMAP/Transformer.sh000066400000000000000000000006051443355502200233110ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SMAP \ --model_id SMAP \ --model Transformer \ --data SMAP \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 25 \ --c_out 25 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/anomaly_detection/SMD/000077500000000000000000000000001443355502200203355ustar00rootroot00000000000000library/scripts/anomaly_detection/SMD/Autoformer.sh000066400000000000000000000006041443355502200230140ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SMD \ --model_id SMD \ --model Autoformer \ --data SMD \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 38 \ --c_out 38 \ --anomaly_ratio 0.5 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/SMD/TimesNet.sh000066400000000000000000000006161443355502200224240ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SMD \ --model_id SMD \ --model TimesNet \ --data SMD \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 64 \ --d_ff 64 \ --e_layers 2 \ --enc_in 38 \ --c_out 38 \ --top_k 5 \ --anomaly_ratio 0.5 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/SMD/Transformer.sh000066400000000000000000000006051443355502200231740ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SMD \ --model_id SMD \ --model Transformer \ --data SMD \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 38 \ --c_out 38 \ --anomaly_ratio 0.5 \ --batch_size 128 \ --train_epochs 10library/scripts/anomaly_detection/SWAT/000077500000000000000000000000001443355502200204705ustar00rootroot00000000000000library/scripts/anomaly_detection/SWAT/Autoformer.sh000066400000000000000000000006221443355502200231470ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model Autoformer \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/anomaly_detection/SWAT/TimesNet.sh000066400000000000000000000056411443355502200225620ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model TimesNet \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 8 \ --d_ff 8 \ --e_layers 3 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model TimesNet \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 16 \ --d_ff 16 \ --e_layers 3 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model TimesNet \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 32 \ --d_ff 32 \ --e_layers 3 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model TimesNet \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 64 \ --d_ff 64 \ --e_layers 3 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model TimesNet \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 8 \ --d_ff 8 \ --e_layers 2 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model TimesNet \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 16 \ --d_ff 16 \ --e_layers 2 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model TimesNet \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 32 \ --d_ff 32 \ --e_layers 2 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model TimesNet \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 64 \ --d_ff 64 \ --e_layers 2 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/anomaly_detection/SWAT/Transformer.sh000066400000000000000000000006231443355502200233270ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 python -u run.py \ --task_name anomaly_detection \ --is_training 1 \ --root_path ./dataset/SWaT \ --model_id SWAT \ --model Transformer \ --data SWAT \ --features M \ --seq_len 100 \ --pred_len 0 \ --d_model 128 \ --d_ff 128 \ --e_layers 3 \ --enc_in 51 \ --c_out 51 \ --top_k 3 \ --anomaly_ratio 1 \ --batch_size 128 \ --train_epochs 3library/scripts/classification/000077500000000000000000000000001443355502200172075ustar00rootroot00000000000000library/scripts/classification/Autoformer.sh000066400000000000000000000071111443355502200216660ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=Autoformer python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/Crossformer.sh000066400000000000000000000071121443355502200220500ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=3 model_name=Crossformer python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/DLinear.sh000066400000000000000000000071061443355502200210650ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=DLinear python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/ETSformer.sh000066400000000000000000000073621443355502200214210ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=ETSformer python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --d_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/FEDformer.sh000066400000000000000000000071101443355502200213530ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=FEDformer python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/FiLM.sh000066400000000000000000000071521443355502200203370ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=FiLM python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --seq_len 1751 \ --pred_len 1751 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/Informer.sh000066400000000000000000000071071443355502200213310ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=Informer python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/LightTS.sh000066400000000000000000000071061443355502200210650ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=LightTS python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/MICN.sh000066400000000000000000000071211443355502200202720ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=MICN python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --c_out 3 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/PatchTST.sh000066400000000000000000000071071443355502200212020ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=3 model_name=PatchTST python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/Pyraformer.sh000066400000000000000000000070771443355502200217040ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=Pyraformer python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 4 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/Reformer.sh000066400000000000000000000071071443355502200213310ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=Reformer python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/classification/TimesNet.sh000066400000000000000000000067101443355502200212770ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=3 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model TimesNet \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 30 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model TimesNet \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 64 \ --d_ff 256 \ --top_k 3 \ --num_kernels 4 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 30 \ --patience 10 python run.py --task_name classification --is_training 1 --root_path ./dataset/Handwriting/ --model_id Handwriting --model TimesNet --data UEA --e_layers 2 --batch_size 16 --d_model 32 --d_ff 64 --top_k 3 --des 'Exp' --itr 1 --learning_rate 0.001 --train_epochs 30 --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model TimesNet \ --data UEA \ --e_layers 2 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --top_k 1 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 30 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model TimesNet \ --data UEA \ --e_layers 2 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 30 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model TimesNet \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 30 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model TimesNet \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 30 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model TimesNet \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 10 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model TimesNet \ --data UEA \ --e_layers 2 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 2 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 30 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model TimesNet \ --data UEA \ --e_layers 2 \ --batch_size 16 \ --d_model 32 \ --d_ff 64 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 30 \ --patience 10 library/scripts/classification/Transformer.sh000066400000000000000000000071121443355502200220460ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=Transformer python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/EthanolConcentration/ \ --model_id EthanolConcentration \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/FaceDetection/ \ --model_id FaceDetection \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Handwriting/ \ --model_id Handwriting \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/Heartbeat/ \ --model_id Heartbeat \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/JapaneseVowels/ \ --model_id JapaneseVowels \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/PEMS-SF/ \ --model_id PEMS-SF \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP1/ \ --model_id SelfRegulationSCP1 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SelfRegulationSCP2/ \ --model_id SelfRegulationSCP2 \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/SpokenArabicDigits/ \ --model_id SpokenArabicDigits \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 python -u run.py \ --task_name classification \ --is_training 1 \ --root_path ./dataset/UWaveGestureLibrary/ \ --model_id UWaveGestureLibrary \ --model $model_name \ --data UEA \ --e_layers 3 \ --batch_size 16 \ --d_model 128 \ --d_ff 256 \ --top_k 3 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --train_epochs 100 \ --patience 10 library/scripts/imputation/000077500000000000000000000000001443355502200164055ustar00rootroot00000000000000library/scripts/imputation/ECL_script/000077500000000000000000000000001443355502200203745ustar00rootroot00000000000000library/scripts/imputation/ECL_script/Autoformer.sh000066400000000000000000000041131443355502200230520ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Autoformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ECL_script/DLinear.sh000066400000000000000000000040641443355502200222520ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=DLinear python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ECL_script/ETSformer.sh000066400000000000000000000041121443355502200225740ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=ETSformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ECL_script/FEDformer.sh000066400000000000000000000041121443355502200225370ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=FEDformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ECL_script/Informer.sh000066400000000000000000000041111443355502200225060ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Informer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ECL_script/LightTS.sh000066400000000000000000000041141443355502200222460ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=LightTS python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ECL_script/Pyraformer.sh000066400000000000000000000041131443355502200230550ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Pyraformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ECL_script/Reformer.sh000066400000000000000000000041111443355502200225060ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Reformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ECL_script/TimesNet.sh000066400000000000000000000041011443355502200224540ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=TimesNet python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 library/scripts/imputation/ECL_script/Transformer.sh000066400000000000000000000041141443355502200232320ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Transformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/000077500000000000000000000000001443355502200204255ustar00rootroot00000000000000library/scripts/imputation/ETT_script/Autoformer_ETTh1.sh000066400000000000000000000040271443355502200240540ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Autoformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/Autoformer_ETTh2.sh000066400000000000000000000040271443355502200240550ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Autoformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/Autoformer_ETTm1.sh000066400000000000000000000040271443355502200240610ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Autoformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/Autoformer_ETTm2.sh000066400000000000000000000040271443355502200240620ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Autoformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/Crossformer_ETTh1.sh000066400000000000000000000040201443355502200242260ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Crossformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/DLinear_ETTh1.sh000066400000000000000000000040301443355502200232410ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=DLinear python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/FiLM_ETTh1.sh000066400000000000000000000040151443355502200225150ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=FiLM python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/MICN_ETTh1.sh000066400000000000000000000041511443355502200224550ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=MICN python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --conv_kernel 12 16 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --conv_kernel 12 16 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --conv_kernel 12 16 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --conv_kernel 12 16 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/Nonstationary_Transformer_ETTh1.sh000066400000000000000000000043661443355502200271710ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Nonstationary_Transformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 library/scripts/imputation/ETT_script/TimesNet_ETTh1.sh000066400000000000000000000040151443355502200234560ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=TimesNet python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 16 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 16 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 16 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 16 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/TimesNet_ETTh2.sh000066400000000000000000000040151443355502200234570ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=TimesNet python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/TimesNet_ETTm1.sh000066400000000000000000000040151443355502200234630ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=TimesNet python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/TimesNet_ETTm2.sh000066400000000000000000000040151443355502200234640ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=TimesNet python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/Transformer_ETTh1.sh000066400000000000000000000040301443355502200242250ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Transformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/Transformer_ETTh2.sh000066400000000000000000000040301443355502200242260ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Transformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/Transformer_ETTm1.sh000066400000000000000000000040301443355502200242320ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Transformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/ETT_script/Transformer_ETTm2.sh000066400000000000000000000040301443355502200242330ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Transformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/Weather_script/000077500000000000000000000000001443355502200213705ustar00rootroot00000000000000library/scripts/imputation/Weather_script/Autoformer.sh000066400000000000000000000040571443355502200240550ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Autoformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/imputation/Weather_script/TimesNet.sh000066400000000000000000000040451443355502200234570ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=TimesNet python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --des 'Exp' \ --itr 1 \ --top_k 3 \ --learning_rate 0.001 library/scripts/imputation/Weather_script/Transformer.sh000066400000000000000000000040601443355502200242260ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Transformer python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.125 \ --mask_rate 0.125 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.25 \ --mask_rate 0.25 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.375 \ --mask_rate 0.375 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 python -u run.py \ --task_name imputation \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_mask_0.5 \ --mask_rate 0.5 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 0 \ --pred_len 0 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --batch_size 16 \ --d_model 128 \ --d_ff 128 \ --des 'Exp' \ --itr 1 \ --top_k 5 \ --learning_rate 0.001 library/scripts/long_term_forecast/000077500000000000000000000000001443355502200200705ustar00rootroot00000000000000library/scripts/long_term_forecast/ECL_script/000077500000000000000000000000001443355502200220575ustar00rootroot00000000000000library/scripts/long_term_forecast/ECL_script/Autoformer.sh000066400000000000000000000032361443355502200245420ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Autoformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/Crossformer.sh000066400000000000000000000036531443355502200247260ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=Crossformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --batch_size 16 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --batch_size 16 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --batch_size 16 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --batch_size 16 \ --itr 1library/scripts/long_term_forecast/ECL_script/DLinear.sh000066400000000000000000000032331443355502200237320ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=DLinear python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/ETSformer.sh000066400000000000000000000032351443355502200242640ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=ETSformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/FEDformer.sh000066400000000000000000000032351443355502200242270ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Fedformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/FiLM.sh000066400000000000000000000033501443355502200232030ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=3 model_name=FiLM python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features S \ --seq_len 192 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --batch_size 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features S \ --seq_len 192 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --batch_size 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features S \ --seq_len 192 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --batch_size 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features S \ --seq_len 192 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --batch_size 4 \ --itr 1library/scripts/long_term_forecast/ECL_script/Informer.sh000066400000000000000000000032341443355502200241760ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Informer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/LightTS.sh000066400000000000000000000032331443355502200237320ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=LightTS python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/MICN.sh000066400000000000000000000035241443355502200231450ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=MICN python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/Nonstationary_Transformer.sh000066400000000000000000000036611443355502200276530ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Nonstationary_Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features S \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ --d_model 2048 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features S \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ --d_model 2048 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features S \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ --d_model 2048 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features S \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ --d_model 2048library/scripts/long_term_forecast/ECL_script/PatchTST.sh000066400000000000000000000033541443355502200240520ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=PatchTST python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --batch_size 16 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --batch_size 16 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --batch_size 16 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --batch_size 16 \ --itr 1library/scripts/long_term_forecast/ECL_script/Pyraformer.sh000066400000000000000000000032361443355502200245450ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Pyraformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/Reformer.sh000066400000000000000000000032341443355502200241760ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Reformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/TimesNet.sh000066400000000000000000000035301443355502200241440ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=TimesNet python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 321 \ --dec_in 321 \ --c_out 321 \ --d_model 256 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ECL_script/Transformer.sh000066400000000000000000000032071443355502200247170ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_96 \ --model $model_name \ --data custom \ --features S \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_192 \ --model $model_name \ --data custom \ --features S \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_336 \ --model $model_name \ --data custom \ --features S \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/electricity/ \ --data_path electricity.csv \ --model_id ECL_96_720 \ --model $model_name \ --data custom \ --features S \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/000077500000000000000000000000001443355502200221105ustar00rootroot00000000000000library/scripts/long_term_forecast/ETT_script/Autoformer_ETTh1.sh000066400000000000000000000031521443355502200255350ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Autoformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Autoformer_ETTh2.sh000066400000000000000000000031521443355502200255360ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Autoformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_96 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_192 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_336 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_720 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Autoformer_ETTm1.sh000066400000000000000000000031521443355502200255420ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Autoformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_96 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_192 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_336 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_720 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Autoformer_ETTm2.sh000066400000000000000000000031521443355502200255430ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Autoformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_96 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_192 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_336 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_720 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Crossformer_ETTh1.sh000066400000000000000000000031531443355502200257170ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Crossformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Crossformer_ETTh2.sh000066400000000000000000000031531443355502200257200ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Crossformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_96 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_192 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_336 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_720 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Crossformer_ETTm1.sh000066400000000000000000000030571443355502200257270ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Crossformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_96 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_192 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_336 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_720 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Crossformer_ETTm2.sh000066400000000000000000000031531443355502200257250ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=Crossformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_96 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_192 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_336 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_720 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/DLinear_ETTh1.sh000066400000000000000000000031471443355502200247340ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=DLinear python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/ETSformer_ETTh1.sh000066400000000000000000000031511443355502200252570ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=ETSformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/FEDformer_ETTh1.sh000066400000000000000000000031511443355502200252220ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=FEDformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/FiLM_ETTh1.sh000066400000000000000000000031501443355502200241770ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=FiLM python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 336 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 336 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 336 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 336 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/FiLM_ETTh2.sh000066400000000000000000000031501443355502200242000ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=FiLM python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_96 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 168 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_192 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 168 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_336 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 168 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_720 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 168 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/FiLM_ETTm1.sh000066400000000000000000000031501443355502200242040ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=FiLM python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_96 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_192 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_336 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_720 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/FiLM_ETTm2.sh000066400000000000000000000031501443355502200242050ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=3 model_name=FiLM python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_96 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_192 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_336 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_720 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Informer_ETTh1.sh000066400000000000000000000031501443355502200251710ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Informer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/LightTS_ETTh1.sh000066400000000000000000000031471443355502200247340ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=LightTS python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/MICN_ETTh1.sh000066400000000000000000000031451443355502200241420ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=MICN python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 library/scripts/long_term_forecast/ETT_script/MICN_ETTh2.sh000066400000000000000000000031451443355502200241430ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=MICN python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_96 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_192 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_336 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_720 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 library/scripts/long_term_forecast/ETT_script/MICN_ETTm1.sh000066400000000000000000000032341443355502200241460ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=MICN python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_96 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_192 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_336 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_720 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --top_k 5 \ --itr 1library/scripts/long_term_forecast/ETT_script/MICN_ETTm2.sh000066400000000000000000000032341443355502200241470ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=MICN python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_96 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_192 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_336 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_720 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --top_k 5 \ --itr 1library/scripts/long_term_forecast/ETT_script/Nonstationary_Transformer_ETTh1.sh000066400000000000000000000036211443355502200306450ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Nonstationary_Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ --d_model 128 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ --d_model 128 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ --d_model 128 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ --d_model 128library/scripts/long_term_forecast/ETT_script/Nonstationary_Transformer_ETTh2.sh000066400000000000000000000035321443355502200306470ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=Nonstationary_Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_96 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_192 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_336 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 256 256 \ --p_hidden_layers 4 \ python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_720 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 \ library/scripts/long_term_forecast/ETT_script/Nonstationary_Transformer_ETTm1.sh000066400000000000000000000034351443355502200306550ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=3 model_name=Nonstationary_Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_96 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 16 16 16 16 \ --p_hidden_layers 4 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_192 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 16 16 16 16 \ --p_hidden_layers 4 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_336 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 16 16 16 16 \ --p_hidden_layers 4 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_720 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 16 16 16 16 \ --p_hidden_layers 4library/scripts/long_term_forecast/ETT_script/Nonstationary_Transformer_ETTm2.sh000066400000000000000000000035411443355502200306540ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=Nonstationary_Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_96 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 256 256 \ --p_hidden_layers 4 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_192 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 256 256 \ --p_hidden_layers 4 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_336 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 16 16 16 16 \ --p_hidden_layers 4 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_720 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 16 16 16 16 \ --p_hidden_layers 4library/scripts/long_term_forecast/ETT_script/PatchTST_ETTh1.sh000066400000000000000000000032511443355502200250440ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=PatchTST python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 1 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 2 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 1 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 8 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 1 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 8 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 1 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 16 \ --itr 1library/scripts/long_term_forecast/ETT_script/PatchTST_ETTh2.sh000066400000000000000000000032501443355502200250440ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=PatchTST python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_96 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 3 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_192 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 3 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_336 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 3 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_720 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 3 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --itr 1library/scripts/long_term_forecast/ETT_script/PatchTST_ETTm1.sh000066400000000000000000000033731443355502200250560ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=PatchTST python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_96 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 1 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 2 \ --batch_size 32 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_192 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 3 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 2 \ --batch_size 128 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_336 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 1 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --batch_size 128 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_720 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 3 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --batch_size 128 \ --itr 1library/scripts/long_term_forecast/ETT_script/PatchTST_ETTm2.sh000066400000000000000000000033731443355502200250570ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=PatchTST python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_96 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 3 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 16 \ --batch_size 32 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_192 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 3 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 2 \ --batch_size 128 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_336 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 1 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --batch_size 32 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_720 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 3 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --batch_size 128 \ --itr 1library/scripts/long_term_forecast/ETT_script/Pyraformer_ETTh1.sh000066400000000000000000000031521443355502200255400ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Pyraformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Pyraformer_ETTh2.sh000066400000000000000000000031521443355502200255410ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Pyraformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_96 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_192 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_336 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_720 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Pyraformer_ETTm1.sh000066400000000000000000000031521443355502200255450ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Pyraformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_96 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_192 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_336 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_720 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Pyraformer_ETTm2.sh000066400000000000000000000031521443355502200255460ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Pyraformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_96 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_192 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_336 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_720 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Reformer_ETTh1.sh000066400000000000000000000031501443355502200251710ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Reformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/TimesNet_ETTh1.sh000066400000000000000000000034371443355502200251500ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=TimesNet python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 16 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 5 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 16 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 5 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 16 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 5 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 16 \ --d_ff 32 \ --des 'Exp' \ --itr 1 \ --top_k 5library/scripts/long_term_forecast/ETT_script/TimesNet_ETTh2.sh000066400000000000000000000034351443355502200251470ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=TimesNet python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_96 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_192 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_336 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_720 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 library/scripts/long_term_forecast/ETT_script/TimesNet_ETTm1.sh000066400000000000000000000034611443355502200251520ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=TimesNet python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_96 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_192 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_336 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --d_model 16 \ --d_ff 32 \ --top_k 5 \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_720 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --d_model 16 \ --d_ff 32 \ --top_k 5 \ --itr 1library/scripts/long_term_forecast/ETT_script/TimesNet_ETTm2.sh000066400000000000000000000035061443355502200251530ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=TimesNet python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_96 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_192 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_336 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_720 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --d_model 16 \ --d_ff 32 \ --top_k 5 \ --itr 1 \ --train_epochs 1library/scripts/long_term_forecast/ETT_script/Transformer_ETTh1.sh000066400000000000000000000031531443355502200257150ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_96 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_192 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_336 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh1.csv \ --model_id ETTh1_96_720 \ --model $model_name \ --data ETTh1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Transformer_ETTh2.sh000066400000000000000000000031531443355502200257160ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_96 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_192 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_336 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTh2.csv \ --model_id ETTh2_96_720 \ --model $model_name \ --data ETTh2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Transformer_ETTm1.sh000066400000000000000000000030571443355502200257250ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_96 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_192 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_336 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm1.csv \ --model_id ETTm1_96_720 \ --model $model_name \ --data ETTm1 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ETT_script/Transformer_ETTm2.sh000066400000000000000000000031531443355502200257230ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=2 model_name=Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_96 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_192 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_336 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/ETT-small/ \ --data_path ETTm2.csv \ --model_id ETTm2_96_720 \ --model $model_name \ --data ETTm2 \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 1 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/Exchange_script/000077500000000000000000000000001443355502200231765ustar00rootroot00000000000000library/scripts/long_term_forecast/Exchange_script/Autoformer.sh000066400000000000000000000033241443355502200256570ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=Autoformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/Exchange_script/Crossformer.sh000066400000000000000000000036121443355502200260400ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=Crossformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 library/scripts/long_term_forecast/Exchange_script/FiLM.sh000066400000000000000000000032641443355502200243260ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=FiLM python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 384 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 384 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 library/scripts/long_term_forecast/Exchange_script/MICN.sh000066400000000000000000000036031443355502200242620ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=MICN python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 library/scripts/long_term_forecast/Exchange_script/Nonstationary_Transformer.sh000066400000000000000000000036421443355502200307710ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=Nonstationary_Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 64 64 64 64 \ --p_hidden_layers 4 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2library/scripts/long_term_forecast/Exchange_script/PatchTST.sh000066400000000000000000000032751443355502200251730ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=PatchTST python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/Exchange_script/Pyraformer.sh000066400000000000000000000033241443355502200256620ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=Pyraformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/Exchange_script/TimesNet.sh000066400000000000000000000036071443355502200252700ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=TimesNet python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 library/scripts/long_term_forecast/Exchange_script/Transformer.sh000066400000000000000000000033001443355502200260300ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/exchange_rate/ \ --data_path exchange_rate.csv \ --model_id Exchange_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 8 \ --dec_in 8 \ --c_out 8 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ILI_script/000077500000000000000000000000001443355502200220715ustar00rootroot00000000000000library/scripts/long_term_forecast/ILI_script/Autoformer.sh000066400000000000000000000032041443355502200245470ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Autoformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_24 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 24 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_36 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 36 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_48 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 48 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_60 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 60 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ILI_script/Crossformer.sh000066400000000000000000000036061443355502200247360ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=Crossformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_24 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 24 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ --dropout 0.6 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_36 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 36 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ -dropout 0.6 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_48 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 48 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ -dropout 0.6 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_60 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 60 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ -dropout 0.6 \ --itr 1library/scripts/long_term_forecast/ILI_script/FiLM.sh000066400000000000000000000031321443355502200232130ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_24 \ --model FiLM \ --data custom \ --features M \ --seq_len 60 \ --label_len 18 \ --pred_len 24 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_36 \ --model FiLM \ --data custom \ --features M \ --seq_len 60 \ --label_len 18 \ --pred_len 36 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_48 \ --model FiLM \ --data custom \ --features M \ --seq_len 60 \ --label_len 18 \ --pred_len 48 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_60 \ --model FiLM \ --data custom \ --features M \ --seq_len 60 \ --label_len 18 \ --pred_len 60 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ILI_script/MICN.sh000066400000000000000000000036321443355502200231570ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=MICN python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_24 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 36 \ --pred_len 24 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ --conv_kernel 18 12 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_36 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 36 \ --pred_len 36 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ --conv_kernel 18 12 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_48 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 36 \ --pred_len 48 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ --conv_kernel 18 12 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_60 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 36 \ --pred_len 60 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ --conv_kernel 18 12 \ --itr 1library/scripts/long_term_forecast/ILI_script/Nonstationary_Transformer.sh000066400000000000000000000035311443355502200276610ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=3 model_name=Nonstationary_Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_24 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 24 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 32 32 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_36 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 36 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 32 32 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_48 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 48 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 16 16 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_60 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 60 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 8 8 \ --p_hidden_layers 2library/scripts/long_term_forecast/ILI_script/PatchTST.sh000066400000000000000000000034141443355502200240610ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=PatchTST python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_24 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 24 \ --e_layers 4 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --d_model 1024\ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_36 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 36 \ --e_layers 4 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --d_model 2048\ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_48 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 48 \ --e_layers 4 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 4 \ --d_model 2048\ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_60 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 60 \ --e_layers 4 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --n_heads 16 \ --d_model 2048\ --itr 1library/scripts/long_term_forecast/ILI_script/TimesNet.sh000066400000000000000000000034761443355502200241670ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=TimesNet python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_24 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 24 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_36 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 36 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_48 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 48 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_60 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 60 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --d_model 768 \ --d_ff 768 \ --top_k 5 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/ILI_script/Transformer.sh000066400000000000000000000032051443355502200247270ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_24 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 24 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_36 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 36 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_48 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 48 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/illness/ \ --data_path national_illness.csv \ --model_id ili_36_60 \ --model $model_name \ --data custom \ --features M \ --seq_len 36 \ --label_len 18 \ --pred_len 60 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 7 \ --dec_in 7 \ --c_out 7 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/Traffic_script/000077500000000000000000000000001443355502200230325ustar00rootroot00000000000000library/scripts/long_term_forecast/Traffic_script/Autoformer.sh000066400000000000000000000033421443355502200255130ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=Autoformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3library/scripts/long_term_forecast/Traffic_script/Crossformer.sh000066400000000000000000000035231443355502200256750ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=Crossformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --top_k 5 \ --des 'Exp' \ --n_heads 2 \ --batch_size 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --top_k 5 \ --des 'Exp' \ --n_heads 2 \ --batch_size 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --top_k 5 \ --des 'Exp' \ --n_heads 2 \ --batch_size 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --top_k 5 \ --des 'Exp' \ --n_heads 2 \ --batch_size 4 \ --itr 1library/scripts/long_term_forecast/Traffic_script/FiLM.sh000066400000000000000000000033301443355502200241540ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=3 model_name=FiLM python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --batch_size 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --batch_size 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --batch_size 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --batch_size 2library/scripts/long_term_forecast/Traffic_script/MICN.sh000066400000000000000000000035041443355502200241160ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=MICN python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/Traffic_script/Nonstationary_Transformer.sh000066400000000000000000000036771443355502200306350ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=Nonstationary_Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 \ --p_hidden_dims 128 128 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 \ --p_hidden_dims 128 128 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 \ --p_hidden_dims 16 16 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 \ --p_hidden_dims 128 128 \ --p_hidden_layers 2library/scripts/long_term_forecast/Traffic_script/PatchTST.sh000066400000000000000000000036241443355502200250250ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=PatchTST python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --batch_size 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --batch_size 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --batch_size 4 \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --batch_size 4 \ --itr 1library/scripts/long_term_forecast/Traffic_script/Pyraformer.sh000066400000000000000000000033421443355502200255160ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=Pyraformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --des 'Exp' \ --itr 1 \ --train_epochs 3library/scripts/long_term_forecast/Traffic_script/TimesNet.sh000066400000000000000000000035101443355502200251150ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=TimesNet python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 862 \ --dec_in 862 \ --c_out 862 \ --d_model 512 \ --d_ff 512 \ --top_k 5 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/Traffic_script/Transformer.sh000066400000000000000000000033131443355502200256700ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/traffic/ \ --data_path traffic.csv \ --model_id traffic_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --des 'Exp' \ --itr 1 \ --train_epochs 3library/scripts/long_term_forecast/Weather_script/000077500000000000000000000000001443355502200230535ustar00rootroot00000000000000library/scripts/long_term_forecast/Weather_script/Autoformer.sh000066400000000000000000000032271443355502200255360ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Autoformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --train_epochs 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/Weather_script/Crossformer.sh000066400000000000000000000035421443355502200257170ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=Crossformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1library/scripts/long_term_forecast/Weather_script/FiLM.sh000066400000000000000000000031231443355502200241750ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_720 \ --model FiLM \ --data custom \ --features M \ --seq_len 720 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_96 \ --model FiLM \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_192 \ --model FiLM \ --data custom \ --features M \ --seq_len 192 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_336 \ --model FiLM \ --data custom \ --features M \ --seq_len 336 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 library/scripts/long_term_forecast/Weather_script/MICN.sh000066400000000000000000000035331443355502200241410ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=MICN python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 96 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1library/scripts/long_term_forecast/Weather_script/Nonstationary_Transformer.sh000066400000000000000000000035661443355502200306530ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=6 model_name=Nonstationary_Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 128 128 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 128 128 \ --p_hidden_layers 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --p_hidden_dims 128 128 \ --p_hidden_layers 2library/scripts/long_term_forecast/Weather_script/PatchTST.sh000066400000000000000000000034771443355502200250540ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=0 model_name=PatchTST python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --n_heads 4 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --n_heads 16 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --n_heads 4 \ --batch_size 128 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --n_heads 4 \ --batch_size 128 \ --train_epochs 3library/scripts/long_term_forecast/Weather_script/Pyraformer.sh000066400000000000000000000032271443355502200255410ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=Pyraformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --train_epochs 2 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1library/scripts/long_term_forecast/Weather_script/TimesNet.sh000066400000000000000000000035371443355502200251470ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=TimesNet python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --train_epochs 1library/scripts/long_term_forecast/Weather_script/Transformer.sh000066400000000000000000000032301443355502200257070ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=7 model_name=Transformer python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_96 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 96 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 \ --train_epochs 3 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_192 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 192 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_336 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 336 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1 python -u run.py \ --task_name long_term_forecast \ --is_training 1 \ --root_path ./dataset/weather/ \ --data_path weather.csv \ --model_id weather_96_720 \ --model $model_name \ --data custom \ --features M \ --seq_len 96 \ --label_len 48 \ --pred_len 720 \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 21 \ --dec_in 21 \ --c_out 21 \ --des 'Exp' \ --itr 1library/scripts/short_term_forecast/000077500000000000000000000000001443355502200202705ustar00rootroot00000000000000library/scripts/short_term_forecast/Autoformer_M4.sh000066400000000000000000000050231443355502200233070ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Autoformer python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' library/scripts/short_term_forecast/Crossformer_M4.sh000066400000000000000000000052651443355502200235000ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=5 model_name=Crossformer python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 16 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 16 \ --d_ff 16 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE'library/scripts/short_term_forecast/DLinear_M4.sh000066400000000000000000000050201443355502200224770ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=DLinear python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' library/scripts/short_term_forecast/ETSformer_M4.sh000066400000000000000000000050231443355502200230320ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=ETSformer python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ../dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 2 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' library/scripts/short_term_forecast/FEDformer_M4.sh000066400000000000000000000050221443355502200227740ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=FEDformer python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' library/scripts/short_term_forecast/FiLM_M4.sh000066400000000000000000000052561443355502200217630ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=3 model_name=FiLM python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 16 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 16 \ --d_ff 16 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE'library/scripts/short_term_forecast/Informer_M4.sh000066400000000000000000000050211443355502200227430ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Informer python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' library/scripts/short_term_forecast/LightTS_M4.sh000066400000000000000000000050201443355502200224770ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=LightTS python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' library/scripts/short_term_forecast/MICN_M4.sh000066400000000000000000000052561443355502200217220ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=4 model_name=MICN python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 16 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 16 \ --d_ff 16 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE'library/scripts/short_term_forecast/Nonstationary_Transformer_M4.sh000066400000000000000000000055311443355502200264220ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Nonstationary_Transformer python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' \ --p_hidden_dims 256 256 \ --p_hidden_layers 2 python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' \ --p_hidden_dims 256 256 \ --p_hidden_layers 2library/scripts/short_term_forecast/Pyraformer_M4.sh000066400000000000000000000050231443355502200233120ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Pyraformer python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' library/scripts/short_term_forecast/Reformer_M4.sh000066400000000000000000000050211443355502200227430ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Reformer python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' library/scripts/short_term_forecast/TimesNet_M4.sh000066400000000000000000000052631443355502200227220ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=TimesNet python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 16 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 64 \ --d_ff 64 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 16 \ --d_ff 16 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 32 \ --d_ff 32 \ --top_k 5 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' library/scripts/short_term_forecast/Transformer_M4.sh000066400000000000000000000050231443355502200234660ustar00rootroot00000000000000export CUDA_VISIBLE_DEVICES=1 model_name=Transformer python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Monthly' \ --model_id m4_Monthly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Yearly' \ --model_id m4_Yearly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Quarterly' \ --model_id m4_Quarterly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Weekly' \ --model_id m4_Weekly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Daily' \ --model_id m4_Daily \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE' python -u run.py \ --task_name short_term_forecast \ --is_training 1 \ --root_path ./dataset/m4 \ --seasonal_patterns 'Hourly' \ --model_id m4_Hourly \ --model $model_name \ --data m4 \ --features M \ --e_layers 2 \ --d_layers 1 \ --factor 3 \ --enc_in 1 \ --dec_in 1 \ --c_out 1 \ --batch_size 16 \ --d_model 512 \ --des 'Exp' \ --itr 1 \ --learning_rate 0.001 \ --loss 'SMAPE'library/utils/000077500000000000000000000000001443355502200136655ustar00rootroot00000000000000library/utils/__init__.py000066400000000000000000000000001443355502200157640ustar00rootroot00000000000000library/utils/losses.py000066400000000000000000000066031443355502200155540ustar00rootroot00000000000000# This source code is provided for the purposes of scientific reproducibility # under the following limited license from Element AI Inc. The code is an # implementation of the N-BEATS model (Oreshkin et al., N-BEATS: Neural basis # expansion analysis for interpretable time series forecasting, # https://arxiv.org/abs/1905.10437). The copyright to the source code is # licensed under the Creative Commons - Attribution-NonCommercial 4.0 # International license (CC BY-NC 4.0): # https://creativecommons.org/licenses/by-nc/4.0/. Any commercial use (whether # for the benefit of third parties or internally in production) requires an # explicit license. The subject-matter of the N-BEATS model and associated # materials are the property of Element AI Inc. and may be subject to patent # protection. No license to patents is granted hereunder (whether express or # implied). Copyright © 2020 Element AI Inc. All rights reserved. """ Loss functions for PyTorch. """ import torch as t import torch.nn as nn import numpy as np import pdb def divide_no_nan(a, b): """ a/b where the resulted NaN or Inf are replaced by 0. """ result = a / b result[result != result] = .0 result[result == np.inf] = .0 return result class mape_loss(nn.Module): def __init__(self): super(mape_loss, self).__init__() def forward(self, insample: t.Tensor, freq: int, forecast: t.Tensor, target: t.Tensor, mask: t.Tensor) -> t.float: """ MAPE loss as defined in: https://en.wikipedia.org/wiki/Mean_absolute_percentage_error :param forecast: Forecast values. Shape: batch, time :param target: Target values. Shape: batch, time :param mask: 0/1 mask. Shape: batch, time :return: Loss value """ weights = divide_no_nan(mask, target) return t.mean(t.abs((forecast - target) * weights)) class smape_loss(nn.Module): def __init__(self): super(smape_loss, self).__init__() def forward(self, insample: t.Tensor, freq: int, forecast: t.Tensor, target: t.Tensor, mask: t.Tensor) -> t.float: """ sMAPE loss as defined in https://robjhyndman.com/hyndsight/smape/ (Makridakis 1993) :param forecast: Forecast values. Shape: batch, time :param target: Target values. Shape: batch, time :param mask: 0/1 mask. Shape: batch, time :return: Loss value """ return 200 * t.mean(divide_no_nan(t.abs(forecast - target), t.abs(forecast.data) + t.abs(target.data)) * mask) class mase_loss(nn.Module): def __init__(self): super(mase_loss, self).__init__() def forward(self, insample: t.Tensor, freq: int, forecast: t.Tensor, target: t.Tensor, mask: t.Tensor) -> t.float: """ MASE loss as defined in "Scaled Errors" https://robjhyndman.com/papers/mase.pdf :param insample: Insample values. Shape: batch, time_i :param freq: Frequency value :param forecast: Forecast values. Shape: batch, time_o :param target: Target values. Shape: batch, time_o :param mask: 0/1 mask. Shape: batch, time_o :return: Loss value """ masep = t.mean(t.abs(insample[:, freq:] - insample[:, :-freq]), dim=1) masked_masep_inv = divide_no_nan(mask, masep[:, None]) return t.mean(t.abs(target - forecast) * masked_masep_inv) library/utils/m4_summary.py000066400000000000000000000140361443355502200163400ustar00rootroot00000000000000# This source code is provided for the purposes of scientific reproducibility # under the following limited license from Element AI Inc. The code is an # implementation of the N-BEATS model (Oreshkin et al., N-BEATS: Neural basis # expansion analysis for interpretable time series forecasting, # https://arxiv.org/abs/1905.10437). The copyright to the source code is # licensed under the Creative Commons - Attribution-NonCommercial 4.0 # International license (CC BY-NC 4.0): # https://creativecommons.org/licenses/by-nc/4.0/. Any commercial use (whether # for the benefit of third parties or internally in production) requires an # explicit license. The subject-matter of the N-BEATS model and associated # materials are the property of Element AI Inc. and may be subject to patent # protection. No license to patents is granted hereunder (whether express or # implied). Copyright 2020 Element AI Inc. All rights reserved. """ M4 Summary """ from collections import OrderedDict import numpy as np import pandas as pd from data_provider.m4 import M4Dataset from data_provider.m4 import M4Meta import os def group_values(values, groups, group_name): return np.array([v[~np.isnan(v)] for v in values[groups == group_name]]) def mase(forecast, insample, outsample, frequency): return np.mean(np.abs(forecast - outsample)) / np.mean(np.abs(insample[:-frequency] - insample[frequency:])) def smape_2(forecast, target): denom = np.abs(target) + np.abs(forecast) # divide by 1.0 instead of 0.0, in case when denom is zero the enumerator will be 0.0 anyway. denom[denom == 0.0] = 1.0 return 200 * np.abs(forecast - target) / denom def mape(forecast, target): denom = np.abs(target) # divide by 1.0 instead of 0.0, in case when denom is zero the enumerator will be 0.0 anyway. denom[denom == 0.0] = 1.0 return 100 * np.abs(forecast - target) / denom class M4Summary: def __init__(self, file_path, root_path): self.file_path = file_path self.training_set = M4Dataset.load(training=True, dataset_file=root_path) self.test_set = M4Dataset.load(training=False, dataset_file=root_path) self.naive_path = os.path.join(root_path, 'submission-Naive2.csv') def evaluate(self): """ Evaluate forecasts using M4 test dataset. :param forecast: Forecasts. Shape: timeseries, time. :return: sMAPE and OWA grouped by seasonal patterns. """ grouped_owa = OrderedDict() naive2_forecasts = pd.read_csv(self.naive_path).values[:, 1:].astype(np.float32) naive2_forecasts = np.array([v[~np.isnan(v)] for v in naive2_forecasts]) model_mases = {} naive2_smapes = {} naive2_mases = {} grouped_smapes = {} grouped_mapes = {} for group_name in M4Meta.seasonal_patterns: file_name = self.file_path + group_name + "_forecast.csv" if os.path.exists(file_name): model_forecast = pd.read_csv(file_name).values naive2_forecast = group_values(naive2_forecasts, self.test_set.groups, group_name) target = group_values(self.test_set.values, self.test_set.groups, group_name) # all timeseries within group have same frequency frequency = self.training_set.frequencies[self.test_set.groups == group_name][0] insample = group_values(self.training_set.values, self.test_set.groups, group_name) model_mases[group_name] = np.mean([mase(forecast=model_forecast[i], insample=insample[i], outsample=target[i], frequency=frequency) for i in range(len(model_forecast))]) naive2_mases[group_name] = np.mean([mase(forecast=naive2_forecast[i], insample=insample[i], outsample=target[i], frequency=frequency) for i in range(len(model_forecast))]) naive2_smapes[group_name] = np.mean(smape_2(naive2_forecast, target)) grouped_smapes[group_name] = np.mean(smape_2(forecast=model_forecast, target=target)) grouped_mapes[group_name] = np.mean(mape(forecast=model_forecast, target=target)) grouped_smapes = self.summarize_groups(grouped_smapes) grouped_mapes = self.summarize_groups(grouped_mapes) grouped_model_mases = self.summarize_groups(model_mases) grouped_naive2_smapes = self.summarize_groups(naive2_smapes) grouped_naive2_mases = self.summarize_groups(naive2_mases) for k in grouped_model_mases.keys(): grouped_owa[k] = (grouped_model_mases[k] / grouped_naive2_mases[k] + grouped_smapes[k] / grouped_naive2_smapes[k]) / 2 def round_all(d): return dict(map(lambda kv: (kv[0], np.round(kv[1], 3)), d.items())) return round_all(grouped_smapes), round_all(grouped_owa), round_all(grouped_mapes), round_all( grouped_model_mases) def summarize_groups(self, scores): """ Re-group scores respecting M4 rules. :param scores: Scores per group. :return: Grouped scores. """ scores_summary = OrderedDict() def group_count(group_name): return len(np.where(self.test_set.groups == group_name)[0]) weighted_score = {} for g in ['Yearly', 'Quarterly', 'Monthly']: weighted_score[g] = scores[g] * group_count(g) scores_summary[g] = scores[g] others_score = 0 others_count = 0 for g in ['Weekly', 'Daily', 'Hourly']: others_score += scores[g] * group_count(g) others_count += group_count(g) weighted_score['Others'] = others_score scores_summary['Others'] = others_score / others_count average = np.sum(list(weighted_score.values())) / len(self.test_set.groups) scores_summary['Average'] = average return scores_summary library/utils/masking.py000066400000000000000000000015001443355502200156640ustar00rootroot00000000000000import torch class TriangularCausalMask(): def __init__(self, B, L, device="cpu"): mask_shape = [B, 1, L, L] with torch.no_grad(): self._mask = torch.triu(torch.ones(mask_shape, dtype=torch.bool), diagonal=1).to(device) @property def mask(self): return self._mask class ProbMask(): def __init__(self, B, H, L, index, scores, device="cpu"): _mask = torch.ones(L, scores.shape[-1], dtype=torch.bool).to(device).triu(1) _mask_ex = _mask[None, None, :].expand(B, H, L, scores.shape[-1]) indicator = _mask_ex[torch.arange(B)[:, None, None], torch.arange(H)[None, :, None], index, :].to(device) self._mask = indicator.view(scores.shape).to(device) @property def mask(self): return self._mask library/utils/metrics.py000066400000000000000000000015421443355502200157070ustar00rootroot00000000000000import numpy as np def RSE(pred, true): return np.sqrt(np.sum((true - pred) ** 2)) / np.sqrt(np.sum((true - true.mean()) ** 2)) def CORR(pred, true): u = ((true - true.mean(0)) * (pred - pred.mean(0))).sum(0) d = np.sqrt(((true - true.mean(0)) ** 2 * (pred - pred.mean(0)) ** 2).sum(0)) return (u / d).mean(-1) def MAE(pred, true): return np.mean(np.abs(pred - true)) def MSE(pred, true): return np.mean((pred - true) ** 2) def RMSE(pred, true): return np.sqrt(MSE(pred, true)) def MAPE(pred, true): return np.mean(np.abs((pred - true) / true)) def MSPE(pred, true): return np.mean(np.square((pred - true) / true)) def metric(pred, true): mae = MAE(pred, true) mse = MSE(pred, true) rmse = RMSE(pred, true) mape = MAPE(pred, true) mspe = MSPE(pred, true) return mae, mse, rmse, mape, mspe library/utils/timefeatures.py000066400000000000000000000104211443355502200167320ustar00rootroot00000000000000# From: gluonts/src/gluonts/time_feature/_base.py # Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"). # You may not use this file except in compliance with the License. # A copy of the License is located at # # http://www.apache.org/licenses/LICENSE-2.0 # # or in the "license" file accompanying this file. This file is distributed # on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either # express or implied. See the License for the specific language governing # permissions and limitations under the License. from typing import List import numpy as np import pandas as pd from pandas.tseries import offsets from pandas.tseries.frequencies import to_offset class TimeFeature: def __init__(self): pass def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: pass def __repr__(self): return self.__class__.__name__ + "()" class SecondOfMinute(TimeFeature): """Minute of hour encoded as value between [-0.5, 0.5]""" def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: return index.second / 59.0 - 0.5 class MinuteOfHour(TimeFeature): """Minute of hour encoded as value between [-0.5, 0.5]""" def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: return index.minute / 59.0 - 0.5 class HourOfDay(TimeFeature): """Hour of day encoded as value between [-0.5, 0.5]""" def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: return index.hour / 23.0 - 0.5 class DayOfWeek(TimeFeature): """Hour of day encoded as value between [-0.5, 0.5]""" def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: return index.dayofweek / 6.0 - 0.5 class DayOfMonth(TimeFeature): """Day of month encoded as value between [-0.5, 0.5]""" def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: return (index.day - 1) / 30.0 - 0.5 class DayOfYear(TimeFeature): """Day of year encoded as value between [-0.5, 0.5]""" def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: return (index.dayofyear - 1) / 365.0 - 0.5 class MonthOfYear(TimeFeature): """Month of year encoded as value between [-0.5, 0.5]""" def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: return (index.month - 1) / 11.0 - 0.5 class WeekOfYear(TimeFeature): """Week of year encoded as value between [-0.5, 0.5]""" def __call__(self, index: pd.DatetimeIndex) -> np.ndarray: return (index.isocalendar().week - 1) / 52.0 - 0.5 def time_features_from_frequency_str(freq_str: str) -> List[TimeFeature]: """ Returns a list of time features that will be appropriate for the given frequency string. Parameters ---------- freq_str Frequency string of the form [multiple][granularity] such as "12H", "5min", "1D" etc. """ features_by_offsets = { offsets.YearEnd: [], offsets.QuarterEnd: [MonthOfYear], offsets.MonthEnd: [MonthOfYear], offsets.Week: [DayOfMonth, WeekOfYear], offsets.Day: [DayOfWeek, DayOfMonth, DayOfYear], offsets.BusinessDay: [DayOfWeek, DayOfMonth, DayOfYear], offsets.Hour: [HourOfDay, DayOfWeek, DayOfMonth, DayOfYear], offsets.Minute: [ MinuteOfHour, HourOfDay, DayOfWeek, DayOfMonth, DayOfYear, ], offsets.Second: [ SecondOfMinute, MinuteOfHour, HourOfDay, DayOfWeek, DayOfMonth, DayOfYear, ], } offset = to_offset(freq_str) for offset_type, feature_classes in features_by_offsets.items(): if isinstance(offset, offset_type): return [cls() for cls in feature_classes] supported_freq_msg = f""" Unsupported frequency {freq_str} The following frequencies are supported: Y - yearly alias: A M - monthly W - weekly D - daily B - business days H - hourly T - minutely alias: min S - secondly """ raise RuntimeError(supported_freq_msg) def time_features(dates, freq='h'): return np.vstack([feat(dates) for feat in time_features_from_frequency_str(freq)]) library/utils/tools.py000066400000000000000000000065031443355502200154030ustar00rootroot00000000000000import os import numpy as np import torch import matplotlib.pyplot as plt import pandas as pd plt.switch_backend('agg') def adjust_learning_rate(optimizer, epoch, args): # lr = args.learning_rate * (0.2 ** (epoch // 2)) if args.lradj == 'type1': lr_adjust = {epoch: args.learning_rate * (0.5 ** ((epoch - 1) // 1))} elif args.lradj == 'type2': lr_adjust = { 2: 5e-5, 4: 1e-5, 6: 5e-6, 8: 1e-6, 10: 5e-7, 15: 1e-7, 20: 5e-8 } if epoch in lr_adjust.keys(): lr = lr_adjust[epoch] for param_group in optimizer.param_groups: param_group['lr'] = lr print('Updating learning rate to {}'.format(lr)) class EarlyStopping: def __init__(self, patience=7, verbose=False, delta=0): self.patience = patience self.verbose = verbose self.counter = 0 self.best_score = None self.early_stop = False self.val_loss_min = np.Inf self.delta = delta def __call__(self, val_loss, model, path): score = -val_loss if self.best_score is None: self.best_score = score self.save_checkpoint(val_loss, model, path) elif score < self.best_score + self.delta: self.counter += 1 print(f'EarlyStopping counter: {self.counter} out of {self.patience}') if self.counter >= self.patience: self.early_stop = True else: self.best_score = score self.save_checkpoint(val_loss, model, path) self.counter = 0 def save_checkpoint(self, val_loss, model, path): if self.verbose: print(f'Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}). Saving model ...') torch.save(model.state_dict(), path + '/' + 'checkpoint.pth') self.val_loss_min = val_loss class dotdict(dict): """dot.notation access to dictionary attributes""" __getattr__ = dict.get __setattr__ = dict.__setitem__ __delattr__ = dict.__delitem__ class StandardScaler(): def __init__(self, mean, std): self.mean = mean self.std = std def transform(self, data): return (data - self.mean) / self.std def inverse_transform(self, data): return (data * self.std) + self.mean def visual(true, preds=None, name='./pic/test.pdf'): """ Results visualization """ plt.figure() plt.plot(true, label='GroundTruth', linewidth=2) if preds is not None: plt.plot(preds, label='Prediction', linewidth=2) plt.legend() plt.savefig(name, bbox_inches='tight') def adjustment(gt, pred): anomaly_state = False for i in range(len(gt)): if gt[i] == 1 and pred[i] == 1 and not anomaly_state: anomaly_state = True for j in range(i, 0, -1): if gt[j] == 0: break else: if pred[j] == 0: pred[j] = 1 for j in range(i, len(gt)): if gt[j] == 0: break else: if pred[j] == 0: pred[j] = 1 elif gt[i] == 0: anomaly_state = False if anomaly_state: pred[i] = 1 return gt, pred def cal_accuracy(y_pred, y_true): return np.mean(y_pred == y_true)