Upload Time-Series-Library

.gitattributes

@@ -33,3 +33,19 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+dataset/m4/Daily-train.csv filter=lfs diff=lfs merge=lfs -text
+dataset/m4/Monthly-train.csv filter=lfs diff=lfs merge=lfs -text
+dataset/m4/Quarterly-train.csv filter=lfs diff=lfs merge=lfs -text
+dataset/m4/Yearly-train.csv filter=lfs diff=lfs merge=lfs -text
+dataset/m4/submission-Naive2.csv filter=lfs diff=lfs merge=lfs -text
+dataset/poly/polymarket_data_processed_Crypto_test.jsonl filter=lfs diff=lfs merge=lfs -text
+dataset/poly/polymarket_data_processed_Election_test.jsonl filter=lfs diff=lfs merge=lfs -text
+dataset/poly/polymarket_data_processed_Other_test.jsonl filter=lfs diff=lfs merge=lfs -text
+dataset/poly/polymarket_data_processed_Politics_test.jsonl filter=lfs diff=lfs merge=lfs -text
+dataset/poly/polymarket_data_processed_Sports_test.jsonl filter=lfs diff=lfs merge=lfs -text
+dataset/poly/polymarket_data_processed_dev.jsonl filter=lfs diff=lfs merge=lfs -text
+dataset/poly/polymarket_data_processed_test.jsonl filter=lfs diff=lfs merge=lfs -text
+dataset/poly/polymarket_data_processed_train.jsonl filter=lfs diff=lfs merge=lfs -text
+pic/dataset.png filter=lfs diff=lfs merge=lfs -text
+tutorial/conv.png filter=lfs diff=lfs merge=lfs -text
+tutorial/fft.png filter=lfs diff=lfs merge=lfs -text

Autoformer.csv

@@ -0,0 +1,2 @@
+,Politics_testrmse,Politics_testmae,Sports_testrmse,Sports_testmae,Crypto_testrmse,Crypto_testmae,Election_testrmse,Election_testmae,Other_testrmse,Other_testmae,testrmse,testmae
+0,0.39830628510682603,0.32073805520677084,0.3818132712824491,0.31051893144830756,0.3828605477887506,0.308403942223605,0.4182624238680359,0.3396595166127513,0.39639385459888354,0.3268426575370005,0.37177661055284744,0.2993196869106722

CONTRIBUTING.md

@@ -0,0 +1,20 @@
+## Instructions for Contributing to TSlib
+
+Sincerely thanks to all the researchers who want to use or contribute to TSlib.
+
+Since our team may not have enough time to fix all the bugs and catch up with the latest model, your contribution is essential to this project.
+
+### (1) Fix Bug
+
+You can directly propose a pull request and add detailed descriptions to the comment, such as [this pull request](https://github.com/thuml/Time-Series-Library/pull/498).
+
+### (2) Add a new time series model
+
+Thanks to creative researchers, extensive great TS models are presented, which advance this community significantly. If you want to add your model to TSlib, here are some instructions:
+
+- Propose an issue to describe your model and give a link to your paper and official code. We will discuss whether your model is suitable for this library, such as [this issue](https://github.com/thuml/Time-Series-Library/issues/346).
+- Propose a pull request in a similar style as TSlib, which means adding an additional file to ./models and providing corresponding scripts for reproduction, such as [this pull request](https://github.com/thuml/Time-Series-Library/pull/446).
+
+Note: Given that there are a lot of TS models that have been proposed, we may not have enough time to judge which model can be a remarkable supplement to the current library. Thus, we decide ONLY to add the officially published paper to our library. Peer review can be a reliable criterion.
+
+Thanks again for your valuable contributions.

DLinear.csv

@@ -0,0 +1,2 @@
+,Politics_testrmse,Politics_testmae,Sports_testrmse,Sports_testmae,Crypto_testrmse,Crypto_testmae,Election_testrmse,Election_testmae,Other_testrmse,Other_testmae,testrmse,testmae
+0,0.3961972827838396,0.31730998926485693,0.37965161394318636,0.3065756351649381,0.3828125705658356,0.3088032054398474,0.4141024259329349,0.33436751696330935,0.3924656681263207,0.3223706541409388,0.37120005835210995,0.29826033160423604

Informer.csv

@@ -0,0 +1,2 @@
+,Politics_testrmse,Politics_testmae,Sports_testrmse,Sports_testmae,Crypto_testrmse,Crypto_testmae,Election_testrmse,Election_testmae,Other_testrmse,Other_testmae,testrmse,testmae
+0,0.3974158067085375,0.31855139807181687,0.381309328795267,0.30970417269120676,0.38429771883487124,0.3100599430647862,0.4150583272414749,0.33584398433823054,0.3975700532168396,0.3287726753077512,0.3721965853006681,0.2996654640008122

LICENSE

@@ -0,0 +1,21 @@
+MIT 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.

README.md

@@ -0,0 +1,173 @@
+# Time Series Library (TSLib)
+TSLib is an open-source library for deep learning researchers, especially for deep time series analysis.
+
+We provide a neat code base to evaluate advanced deep time series models or develop your model, which covers five mainstream tasks: **long- and short-term forecasting, imputation, anomaly detection, and classification.**
+
+:triangular_flag_on_post:**News** (2024.10) We have included [[TimeXer]](https://arxiv.org/abs/2402.19072), which defined a practical forecasting paradigm: Forecasting with Exogenous Variables. Considering both practicability and computation efficiency, we believe the new forecasting paradigm defined in TimeXer can be the "right" task for future research.
+
+:triangular_flag_on_post:**News** (2024.10) Our lab has open-sourced [[OpenLTM]](https://github.com/thuml/OpenLTM), which provides a distinct pretrain-finetuning paradigm compared to TSLib. If you are interested in Large Time Series Models, you may find this repository helpful.
+
+:triangular_flag_on_post:**News** (2024.07) We wrote a comprehensive survey of [[Deep Time Series Models]](https://arxiv.org/abs/2407.13278) with a rigorous benchmark based on TSLib. In this paper, we summarized the design principles of current time series models supported by insightful experiments, hoping to be helpful to future research.
+
+:triangular_flag_on_post:**News** (2024.04) Many thanks for the great work from [frecklebars](https://github.com/thuml/Time-Series-Library/pull/378). The famous sequential model [Mamba](https://arxiv.org/abs/2312.00752) has been included in our library. See [this file](https://github.com/thuml/Time-Series-Library/blob/main/models/Mamba.py), where you need to install `mamba_ssm` with pip at first.
+
+:triangular_flag_on_post:**News** (2024.03) Given the inconsistent look-back length of various papers, we split the long-term forecasting in the leaderboard into two categories: Look-Back-96 and Look-Back-Searching. We recommend researchers read [TimeMixer](https://openreview.net/pdf?id=7oLshfEIC2), which includes both look-back length settings in experiments for scientific rigor.
+
+:triangular_flag_on_post:**News** (2023.10) We add an implementation to [iTransformer](https://arxiv.org/abs/2310.06625), which is the state-of-the-art model for long-term forecasting. The official code and complete scripts of iTransformer can be found [here](https://github.com/thuml/iTransformer).
+
+:triangular_flag_on_post:**News** (2023.09) We added a detailed [tutorial](https://github.com/thuml/Time-Series-Library/blob/main/tutorial/TimesNet_tutorial.ipynb) for [TimesNet](https://openreview.net/pdf?id=ju_Uqw384Oq) and this library, which is quite friendly to beginners of deep time series analysis.
+
+:triangular_flag_on_post:**News** (2023.02) We release the TSlib as a comprehensive benchmark and code base for time series models, which is extended from our previous GitHub repository [Autoformer](https://github.com/thuml/Autoformer).
+
+## Leaderboard for Time Series Analysis
+
+Till March 2024, the top three models for five different tasks are:
+
+| Model<br>Ranking | Long-term<br>Forecasting<br>Look-Back-96              | Long-term<br/>Forecasting<br/>Look-Back-Searching     | Short-term<br>Forecasting                                    | Imputation                                                   | Classification                                               | Anomaly<br>Detection                               |
+| ---------------- | ----------------------------------------------------- | ----------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ | -------------------------------------------------- |
+| 🥇 1st            | [TimeXer](https://arxiv.org/abs/2402.19072)      | [TimeMixer](https://openreview.net/pdf?id=7oLshfEIC2) | [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            | [iTransformer](https://arxiv.org/abs/2310.06625) | [PatchTST](https://github.com/yuqinie98/PatchTST)     | [Non-stationary<br/>Transformer](https://github.com/thuml/Nonstationary_Transformers) | [Non-stationary<br/>Transformer](https://github.com/thuml/Nonstationary_Transformers) | [Non-stationary<br/>Transformer](https://github.com/thuml/Nonstationary_Transformers) | [FEDformer](https://github.com/MAZiqing/FEDformer) |
+| 🥉 3rd            | [TimeMixer](https://openreview.net/pdf?id=7oLshfEIC2)          | [DLinear](https://arxiv.org/pdf/2205.13504.pdf)       | [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 leaderboard.** If you have proposed advanced and awesome models, you can send us your paper/code link or raise a pull request. We will add them to this repo and update the leaderboard as soon as possible.
+
+**Compared models of this leaderboard.** ☑ means that their codes have already been included in this repo.
+  - [x] **TimeXer** - TimeXer: Empowering Transformers for Time Series Forecasting with Exogenous Variables [[NeurIPS 2024]](https://arxiv.org/abs/2402.19072) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/TimeXer.py)
+  - [x] **TimeMixer** - TimeMixer: Decomposable Multiscale Mixing for Time Series Forecasting [[ICLR 2024]](https://openreview.net/pdf?id=7oLshfEIC2) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/TimeMixer.py).
+  - [x] **TSMixer** - TSMixer: An All-MLP Architecture for Time Series Forecasting [[arXiv 2023]](https://arxiv.org/pdf/2303.06053.pdf) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/TSMixer.py)
+  - [x] **iTransformer** - iTransformer: Inverted Transformers Are Effective for Time Series Forecasting [[ICLR 2024]](https://arxiv.org/abs/2310.06625) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/iTransformer.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] **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 to the leaderboard after a comprehensive evaluation.
+  - [x] **MultiPatchFormer** - A multiscale model for multivariate time series forecasting [[Scientific Reports 2025]](https://www.nature.com/articles/s41598-024-82417-4) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/MultiPatchFormer.py)
+  - [x] **WPMixer** - WPMixer: Efficient Multi-Resolution Mixing for Long-Term Time Series Forecasting [[AAAI 2025]](https://arxiv.org/abs/2412.17176) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/WPMixer.py)
+  - [x] **PAttn** - Are Language Models Actually Useful for Time Series Forecasting? [[NeurIPS 2024]](https://arxiv.org/pdf/2406.16964) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/PAttn.py)
+  - [x] **Mamba** - Mamba: Linear-Time Sequence Modeling with Selective State Spaces [[arXiv 2023]](https://arxiv.org/abs/2312.00752) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/Mamba.py)
+  - [x] **SegRNN** - SegRNN: Segment Recurrent Neural Network for Long-Term Time Series Forecasting [[arXiv 2023]](https://arxiv.org/abs/2308.11200.pdf) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/SegRNN.py).
+  - [x] **Koopa** - Koopa: Learning Non-stationary Time Series Dynamics with Koopman Predictors [[NeurIPS 2023]](https://arxiv.org/pdf/2305.18803.pdf) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/Koopa.py).
+  - [x] **FreTS** - Frequency-domain MLPs are More Effective Learners in Time Series Forecasting [[NeurIPS 2023]](https://arxiv.org/pdf/2311.06184.pdf) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/FreTS.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).
+  - [x] **TiDE** - Long-term Forecasting with TiDE: Time-series Dense Encoder [[arXiv 2023]](https://arxiv.org/pdf/2304.08424.pdf) [[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/TiDE.py).
+  - [x] **SCINet** - SCINet: Time Series Modeling and Forecasting with Sample Convolution and Interaction [[NeurIPS 2022]](https://openreview.net/pdf?id=AyajSjTAzmg)[[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/SCINet.py).
+  - [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] **TFT** - Temporal Fusion Transformers for Interpretable Multi-horizon Time Series Forecasting [[arXiv 2019]](https://arxiv.org/abs/1912.09363)[[Code]](https://github.com/thuml/Time-Series-Library/blob/main/models/TemporalFusionTransformer.py). 
+ 
+## Usage
+
+1. Install Python 3.8. For convenience, execute the following command.
+
+```
+pip install -r requirements.txt
+```
+
+2. Prepare Data. You can obtain the well pre-processed datasets from [[Google Drive]](https://drive.google.com/drive/folders/13Cg1KYOlzM5C7K8gK8NfC-F3EYxkM3D2?usp=sharing) or [[Baidu Drive]](https://pan.baidu.com/s/1r3KhGd0Q9PJIUZdfEYoymg?pwd=i9iy), Then place the downloaded data in the folder`./dataset`. Here is a summary of supported datasets.
+
+<p align="center">
+<img src=".\pic\dataset.png" height = "200" alt="" align=center />
+</p>
+
+3. Train and evaluate model. We provide the experiment scripts for 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`.
+
+Note: 
+
+(1) About classification: Since we include all five tasks in a unified code base, the accuracy of each subtask may fluctuate but the average performance can be reproduced (even a bit better). We have provided the reproduced checkpoints [here](https://github.com/thuml/Time-Series-Library/issues/494).
+
+(2) About anomaly detection: Some discussion about the adjustment strategy in anomaly detection can be found [here](https://github.com/thuml/Anomaly-Transformer/issues/14). The key point is that the adjustment strategy corresponds to an event-level metric.
+
+## 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},
+}
+
+@article{wang2024tssurvey,
+  title={Deep Time Series Models: A Comprehensive Survey and Benchmark},
+  author={Yuxuan Wang and Haixu Wu and Jiaxiang Dong and Yong Liu and Mingsheng Long and Jianmin Wang},
+  booktitle={arXiv preprint arXiv:2407.13278},
+  year={2024},
+}
+```
+
+## Contact
+If you have any questions or suggestions, feel free to contact our maintenance team:
+
+Current:
+- Haixu Wu (Ph.D. student, wuhx23@mails.tsinghua.edu.cn)
+- Yong Liu (Ph.D. student, liuyong21@mails.tsinghua.edu.cn)
+- Yuxuan Wang (Ph.D. student, wangyuxu22@mails.tsinghua.edu.cn)
+- Huikun Weng (Undergraduate, wenghk22@mails.tsinghua.edu.cn)
+
+Previous:
+- Tengge Hu (Master student, htg21@mails.tsinghua.edu.cn)
+- Haoran Zhang (Master student, z-hr20@mails.tsinghua.edu.cn)
+- Jiawei Guo (Undergraduate, guo-jw21@mails.tsinghua.edu.cn)
+
+Or describe it in Issues.
+
+## Acknowledgement
+
+This project is supported by the National Key R&D Program of China (2021YFB1715200).
+
+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/.
+
+## All Thanks To Our Contributors
+
+<a href="https://github.com/thuml/Time-Series-Library/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=thuml/Time-Series-Library" />
+</a>

Reformer.csv

@@ -0,0 +1,2 @@
+,Politics_testrmse,Politics_testmae,Sports_testrmse,Sports_testmae,Crypto_testrmse,Crypto_testmae,Election_testrmse,Election_testmae,Other_testrmse,Other_testmae,testrmse,testmae
+0,0.39759935719372996,0.3176409474228964,0.3804696526717909,0.3091429407280413,0.38329537668949676,0.30926928011712945,0.4144651556154994,0.3346732748303968,0.39416373838022656,0.3253543121596952,0.3719121830741643,0.2993834586683424

data_provider/__init__.py

@@ -0,0 +1 @@
+

data_provider/calculate_window_len.py

@@ -0,0 +1,127 @@
+import json
+from collections import Counter
+
+def analyze_window_history_lengths(filepath):
+    """
+    统计JSONL文件中所有window_history的长度分布
+    
+    Args:
+        filepath: JSONL文件的路径
+        
+    Returns:
+        Counter对象，包含长度分布统计
+    """
+    length_counter = Counter()
+    total_records = 0
+    total_breakpoints = 0
+    total_window_histories = 0
+    
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            for line_num, line in enumerate(f, 1):
+                line = line.strip()
+                if not line:
+                    continue
+                
+                try:
+                    data = json.loads(line)
+                    total_records += 1
+                    
+                    # 检查是否有daily_breakpoints字段
+                    if 'daily_breakpoints' not in data:
+                        print(f"警告: 第{line_num}行没有'daily_breakpoints'字段")
+                        continue
+                    
+                    daily_breakpoints = data['daily_breakpoints']
+                    
+                    # 遍历每个breakpoint
+                    for i, breakpoint in enumerate(daily_breakpoints):
+                        total_breakpoints += 1
+                        
+                        # 检查是否有window_history字段
+                        if 'window_history' not in breakpoint:
+                            print(f"警告: 第{line_num}行的breakpoint[{i}]没有'window_history'字段")
+                            continue
+                        
+                        window_history = breakpoint['window_history']
+                        
+                        # 统计长度
+                        if isinstance(window_history, list):
+                            length = len(window_history)
+                            length_counter[length] += 1
+                            total_window_histories += 1
+                        else:
+                            print(f"警告: 第{line_num}行的breakpoint[{i}]的'window_history'不是列表")
+                
+                except json.JSONDecodeError as e:
+                    print(f"JSON解析错误在第{line_num}行: {e}")
+                    continue
+        
+        return length_counter, total_records, total_breakpoints, total_window_histories
+    
+    except FileNotFoundError:
+        print(f"文件未找到: {filepath}")
+        return None, 0, 0, 0
+    except Exception as e:
+        print(f"发生错误: {e}")
+        return None, 0, 0, 0
+
+def print_statistics(length_counter, total_records, total_breakpoints, total_window_histories):
+    """
+    打印统计结果
+    """
+    print("\n" + "="*60)
+    print("统计摘要:")
+    print("="*60)
+    print(f"总JSON记录数: {total_records}")
+    print(f"总breakpoints数: {total_breakpoints}")
+    print(f"总window_history数: {total_window_histories}")
+    
+    if not length_counter:
+        print("\n没有找到任何window_history数据")
+        return
+    
+    print("\n" + "="*60)
+    print("Window History 长度分布:")
+    print("="*60)
+    print(f"{'长度':<10} {'数量':<10} {'百分比':<10} {'分布图'}")
+    print("-"*60)
+    
+    # 按长度排序
+    for length in sorted(length_counter.keys()):
+        count = length_counter[length]
+        percentage = (count / total_window_histories) * 100
+        bar = '█' * int(percentage / 2)  # 每个█代表2%
+        print(f"{length:<10} {count:<10} {percentage:>6.2f}%   {bar}")
+    
+    print("\n" + "="*60)
+    print("统计信息:")
+    print("="*60)
+    print(f"最小长度: {min(length_counter.keys())}")
+    print(f"最大长度: {max(length_counter.keys())}")
+    
+    # 计算平均长度
+    total_length = sum(length * count for length, count in length_counter.items())
+    avg_length = total_length / total_window_histories
+    print(f"平均长度: {avg_length:.2f}")
+    
+    # 计算中位数
+    sorted_lengths = []
+    for length, count in sorted(length_counter.items()):
+        sorted_lengths.extend([length] * count)
+    median_length = sorted_lengths[len(sorted_lengths) // 2]
+    print(f"中位数长度: {median_length}")
+    
+    print("="*60)
+
+# 使用示例
+if __name__ == "__main__":
+    # 替换成你的JSONL文件路径
+    filepath = "/data/haofeiy2/social-world-model/data/splitted_polymarket/polymarket_data_processed_with_news_train_2024-11-01.jsonl"
+    
+    print(f"正在分析文件: {filepath}")
+    length_counter, total_records, total_breakpoints, total_window_histories = \
+        analyze_window_history_lengths(filepath)
+    
+    if length_counter is not None:
+        print_statistics(length_counter, total_records, total_breakpoints, total_window_histories)

data_provider/data_factory.py

@@ -0,0 +1,88 @@
+from data_provider.data_loader import Dataset_ETT_hour, Dataset_ETT_minute, Dataset_Custom, Dataset_M4, PSMSegLoader, \
+    MSLSegLoader, SMAPSegLoader, SMDSegLoader, SWATSegLoader, UEAloader, Dataset_Poly, Dataset_Kalshi
+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,
+    'poly': Dataset_Poly,
+    'kalshi': Dataset_Kalshi,
+    '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
+
+    shuffle_flag = False if (flag == 'test' or flag == 'TEST') else True
+    drop_last = False
+    batch_size = args.batch_size
+    freq = args.freq
+
+    if args.task_name == 'anomaly_detection':
+        drop_last = False
+        data_set = Data(
+            args = args,
+            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(
+            args = args,
+            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(
+            args = args,
+            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

data_provider/data_loader.py

@@ -0,0 +1,1029 @@
+import 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
+from utils.augmentation import run_augmentation_single
+import json
+
+warnings.filterwarnings('ignore')
+
+
+class Dataset_ETT_hour(Dataset):
+    def __init__(self, args, 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]
+        self.args = args
+        # 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]
+
+        if self.set_type == 0 and self.args.augmentation_ratio > 0:
+            self.data_x, self.data_y, augmentation_tags = run_augmentation_single(self.data_x, self.data_y, self.args)
+
+        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, args, 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]
+        self.args = args
+        # 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]
+
+        if self.set_type == 0 and self.args.augmentation_ratio > 0:
+            self.data_x, self.data_y, augmentation_tags = run_augmentation_single(self.data_x, self.data_y, self.args)
+
+        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, args, 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]
+        self.args = args
+        # 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]
+
+        if self.set_type == 0 and self.args.augmentation_ratio > 0:
+            self.data_x, self.data_y, augmentation_tags = run_augmentation_single(self.data_x, self.data_y, self.args)
+
+        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, args, 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]
+        import pdb
+        pdb.set_trace()
+
+    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[
+                           max(0, 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 Dataset_Poly(Dataset):
+    def __init__(self, args, 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'):
+        self.args = args
+        self.features = features
+        self.target = target
+        self.scale = scale
+        self.inverse = inverse
+        self.timeenc = timeenc
+        self.root_path = root_path
+        self.flag = flag
+        
+        # 从 size 或 args 获取参数
+        # size = [seq_len, label_len, pred_len]
+        if size is not None:
+            self.seq_len = size[0]    # 建议设为 16
+            self.label_len = size[1]  # 建议设为 1
+            self.pred_len = size[2]   # 建议设为 1
+        else:
+            self.seq_len = getattr(args, 'seq_len', 16)
+            self.label_len = getattr(args, 'label_len', 1)
+            self.pred_len = getattr(args, 'pred_len', 1)
+        
+        self.__read_data__()
+
+    def __read_data__(self):
+        # 基础路径
+        base_path = self.root_path
+        category_path = self.root_path
+        
+        # 文件路径映射 (flag -> (目录, 文件名))
+        file_map = {
+            'train': (base_path, 'polymarket_data_processed_with_news_train_2025-11-01.jsonl'),
+            'val': (base_path, 'polymarket_data_processed_with_news_train_2025-11-01.jsonl'),
+            'test': (base_path, 'polymarket_data_processed_with_news_test_2025-11-01.jsonl'),
+            # 分类别测试集（不同目录）
+            'test_Crypto': (category_path, 'polymarket_data_processed_with_news_test_2025-11-01_crypto.jsonl'),
+            'test_Politics': (category_path, 'polymarket_data_processed_with_news_test_2025-11-01_politics.jsonl'),
+            'test_Election': (category_path, 'polymarket_data_processed_with_news_test_2025-11-01_election.jsonl'),
+        }
+        
+        self.timeseries = []
+        
+        # 获取文件路径
+        if self.flag in file_map:
+            dir_path, file_name = file_map[self.flag]
+            file_path = os.path.join(dir_path, file_name)
+        else:
+            file_path = os.path.join(base_path, f'polymarket_data_processed_with_news_{self.flag}_2025-11-01.jsonl')
+        
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Data file not found: {file_path}")
+        
+        all_samples = []
+        skipped = 0
+        total = 0
+        
+        with open(file_path, 'r') as fcc_file:
+            for line in fcc_file:
+                obj = json.loads(line)
+                
+                if 'daily_breakpoints' not in obj:
+                    continue
+                
+                for bp in obj['daily_breakpoints']:
+                    total += 1
+                    window_history = bp.get('window_history', [])
+                    
+                    if len(window_history) < self.seq_len + 1:
+                        skipped += 1
+                        continue
+                    
+                    prices = [e['p'] for e in window_history]
+                    all_samples.append(prices)
+        
+        # 对 train/val 做 80/20 切分
+        if self.flag == 'train':
+            split_idx = int(len(all_samples) * 0.8)
+            self.timeseries = all_samples[:split_idx]
+        elif self.flag == 'val':
+            split_idx = int(len(all_samples) * 0.8)
+            self.timeseries = all_samples[split_idx:]
+        else:
+            self.timeseries = all_samples
+        
+        print(f"[{self.flag}] Loaded {len(self.timeseries)} samples from {os.path.basename(file_path)}")
+        print(f"[{self.flag}] Skipped {skipped}/{total} (seq_len requirement: {self.seq_len + 1})")
+
+    def __getitem__(self, index):
+        sampled_timeseries = self.timeseries[index]
+        
+        # ========== insample: (seq_len, 1) ==========
+        # 取最后 seq_len+1 个点，前 seq_len 个作为输入
+        # 例如：window_history 长度 17，取 [-17:-1] 共 16 个点作为输入
+        insample = np.zeros((self.seq_len, 1), dtype=np.float32)
+        insample_mask = np.zeros((self.seq_len, 1), dtype=np.float32)
+        
+        # 输入：倒数第 seq_len+1 到倒数第 2 个点（不含 after）
+        input_prices = sampled_timeseries[-(self.seq_len + 1):-1]
+        insample[:, 0] = input_prices
+        insample_mask[:, 0] = 1.0
+        
+        # ========== outsample: (label_len + pred_len, 1) ==========
+        # label_len=1 对应 before 点，pred_len=1 对应 after 点
+        outsample = np.zeros((self.label_len + self.pred_len, 1), dtype=np.float32)
+        outsample_mask = np.zeros((self.label_len + self.pred_len, 1), dtype=np.float32)
+        
+        # outsample = [最后 label_len+pred_len 个点]
+        # 即 [before, after] 当 label_len=1, pred_len=1
+        outsample[:, 0] = sampled_timeseries[-(self.label_len + self.pred_len):]
+        outsample_mask[:, 0] = 1.0
+        
+        return insample, outsample, insample_mask, outsample_mask
+
+    def __len__(self):
+        return len(self.timeseries)
+
+    def inverse_transform(self, data):
+        if hasattr(self, 'scaler') and self.scaler is not None:
+            return self.scaler.inverse_transform(data)
+        return data
+
+    def last_insample_window(self):
+        """用于推理时获取所有时间序列的最后输入窗口"""
+        insample = np.zeros((len(self.timeseries), self.seq_len), dtype=np.float32)
+        insample_mask = np.zeros((len(self.timeseries), self.seq_len), dtype=np.float32)
+        
+        for i, ts in enumerate(self.timeseries):
+            input_prices = ts[-(self.seq_len + 1):-1]
+            insample[i, :] = input_prices
+            insample_mask[i, :] = 1.0
+        
+        return insample, insample_mask
+
+
+class PSMSegLoader(Dataset):
+    def __init__(self, args, 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
+        data_len = len(self.train)
+        self.val = self.train[(int)(data_len * 0.8):]
+        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, args, 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
+        data_len = len(self.train)
+        self.val = self.train[(int)(data_len * 0.8):]
+        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, args, 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
+        data_len = len(self.train)
+        self.val = self.train[(int)(data_len * 0.8):]
+        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, args, 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, args, 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
+        data_len = len(self.train)
+        self.val = self.train[(int)(data_len * 0.8):]
+        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, args, root_path, file_list=None, limit_size=None, flag=None):
+        self.args = args
+        self.root_path = root_path
+        self.flag = flag
+        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 ts files contained in `root_path` into a dataframe, optionally choosing from `pattern`
+        Args:
+            root_path: directory containing all individual .ts 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:
+            pattern='*.ts'
+            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):
+        batch_x = self.feature_df.loc[self.all_IDs[ind]].values
+        labels = self.labels_df.loc[self.all_IDs[ind]].values
+        if self.flag == "TRAIN" and self.args.augmentation_ratio > 0:
+            num_samples = len(self.all_IDs)
+            num_columns = self.feature_df.shape[1]
+            seq_len = int(self.feature_df.shape[0] / num_samples)
+            batch_x = batch_x.reshape((1, seq_len, num_columns))
+            batch_x, labels, augmentation_tags = run_augmentation_single(batch_x, labels, self.args)
+
+            batch_x = batch_x.reshape((1 * seq_len, num_columns))
+
+        return self.instance_norm(torch.from_numpy(batch_x)), \
+               torch.from_numpy(labels)
+
+    def __len__(self):
+        return len(self.all_IDs)
+
+
+class Dataset_Kalshi(Dataset):
+    def __init__(self, args, 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'):
+        self.args = args
+        self.features = features
+        self.target = target
+        self.scale = scale
+        self.inverse = inverse
+        self.timeenc = timeenc
+        self.root_path = root_path
+        self.flag = flag
+        
+        # 从 size 或 args 获取参数
+        # size = [seq_len, label_len, pred_len]
+        if size is not None:
+            self.seq_len = size[0]    # 建议设为 16
+            self.label_len = size[1]  # 建议设为 1
+            self.pred_len = size[2]   # 建议设为 1
+        else:
+            self.seq_len = getattr(args, 'seq_len', 16)
+            self.label_len = getattr(args, 'label_len', 1)
+            self.pred_len = getattr(args, 'pred_len', 1)
+        
+        self.__read_data__()
+
+    def __read_data__(self):
+        # 基础路径
+        base_path = self.root_path
+        category_path = base_path
+        
+        # 文件路径映射 (flag -> (目录, 文件名))
+        file_map = {
+            'train': (base_path, 'kalshi_data_processed_with_news_train_2025-11-01.jsonl'),
+            'val': (base_path, 'kalshi_data_processed_with_news_train_2025-11-01.jsonl'),
+            'test': (base_path, 'kalshi_data_processed_with_news_test_2025-11-01.jsonl'),
+            # 分类别测试集（不同目录）
+            'test_Companies': (category_path, 'kalshi_data_processed_with_news_test_2025-11-01_companies.jsonl'),
+            'test_Economics': (category_path, 'kalshi_data_processed_with_news_test_2025-11-01_economics.jsonl'),
+            'test_Entertainment': (category_path, 'kalshi_data_processed_with_news_test_2025-11-01_entertainment.jsonl'),
+            'test_Mentions': (category_path, 'kalshi_data_processed_with_news_test_2025-11-01_mentions.jsonl'),
+            'test_Politics': (category_path, 'kalshi_data_processed_with_news_test_2025-11-01_politics.jsonl'),
+        }
+        
+        self.timeseries = []
+        
+        # 获取文件路径
+        if self.flag in file_map:
+            dir_path, file_name = file_map[self.flag]
+            file_path = os.path.join(dir_path, file_name)
+        else:
+            file_path = os.path.join(base_path, f'kalshi_data_processed_with_news_{self.flag}_2024-11-01.jsonl')
+        
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Data file not found: {file_path}")
+        
+        all_samples = []
+        skipped = 0
+        total = 0
+        
+        with open(file_path, 'r') as fcc_file:
+            for line in fcc_file:
+                obj = json.loads(line)
+                
+                if 'daily_breakpoints' not in obj:
+                    continue
+                
+                for bp in obj['daily_breakpoints']:
+                    total += 1
+                    window_history = bp.get('window_history', [])
+                    
+                    if len(window_history) < self.seq_len + 1:
+                        skipped += 1
+                        continue
+                    
+                    prices = [e['p'] for e in window_history]
+                    all_samples.append(prices)
+        
+        # 对 train/val 做 80/20 切分
+        if self.flag == 'train':
+            split_idx = int(len(all_samples) * 0.8)
+            self.timeseries = all_samples[:split_idx]
+        elif self.flag == 'val':
+            split_idx = int(len(all_samples) * 0.8)
+            self.timeseries = all_samples[split_idx:]
+        else:
+            self.timeseries = all_samples
+        
+        print(f"[{self.flag}] Loaded {len(self.timeseries)} samples from {os.path.basename(file_path)}")
+        print(f"[{self.flag}] Skipped {skipped}/{total} (seq_len requirement: {self.seq_len + 1})")
+
+    def __getitem__(self, index):
+        sampled_timeseries = self.timeseries[index]
+        
+        # ========== insample: (seq_len, 1) ==========
+        # 取最后 seq_len+1 个点，前 seq_len 个作为输入
+        # 例如：window_history 长度 17，取 [-17:-1] 共 16 个点作为输入
+        insample = np.zeros((self.seq_len, 1), dtype=np.float32)
+        insample_mask = np.zeros((self.seq_len, 1), dtype=np.float32)
+        
+        # 输入：倒数第 seq_len+1 到倒数第 2 个点（不含 after）
+        input_prices = sampled_timeseries[-(self.seq_len + 1):-1]
+        insample[:, 0] = input_prices
+        insample_mask[:, 0] = 1.0
+        
+        # ========== outsample: (label_len + pred_len, 1) ==========
+        # label_len=1 对应 before 点，pred_len=1 对应 after 点
+        outsample = np.zeros((self.label_len + self.pred_len, 1), dtype=np.float32)
+        outsample_mask = np.zeros((self.label_len + self.pred_len, 1), dtype=np.float32)
+        
+        # outsample = [最后 label_len+pred_len 个点]
+        # 即 [before, after] 当 label_len=1, pred_len=1
+        outsample[:, 0] = sampled_timeseries[-(self.label_len + self.pred_len):]
+        outsample_mask[:, 0] = 1.0
+        
+        return insample, outsample, insample_mask, outsample_mask
+
+    def __len__(self):
+        return len(self.timeseries)
+
+    def inverse_transform(self, data):
+        if hasattr(self, 'scaler') and self.scaler is not None:
+            return self.scaler.inverse_transform(data)
+        return data
+
+    def last_insample_window(self):
+        """用于推理时获取所有时间序列的最后输入窗口"""
+        insample = np.zeros((len(self.timeseries), self.seq_len), dtype=np.float32)
+        insample_mask = np.zeros((len(self.timeseries), self.seq_len), dtype=np.float32)
+        
+        for i, ts in enumerate(self.timeseries):
+            input_prices = ts[-(self.seq_len + 1):-1]
+            insample[i, :] = input_prices
+            insample_mask[i, :] = 1.0
+        
+        return insample, insample_mask

data_provider/load.py

@@ -0,0 +1,31 @@
+import json
+
+def load_first_jsonl_record(filepath):
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            first_line = f.readline().strip()
+            if first_line:
+                return json.loads(first_line)
+            else:
+                print("文件为空")
+                return None
+    except FileNotFoundError:
+        print(f"文件未找到: {filepath}")
+        return None
+    except json.JSONDecodeError as e:
+        print(f"JSON解析错误: {e}")
+        return None
+    except Exception as e:
+        print(f"发生错误: {e}")
+        return None
+
+# 使用示例
+if __name__ == "__main__":
+    filepath = "/data/haofeiy2/social-world-model/data/splitted_polymarket/polymarket_data_processed_with_news_train_2024-11-01.jsonl"
+    
+    first_record = load_first_jsonl_record(filepath)
+    breakpoint()
+    
+    if first_record:
+        print("第一条记录:")
+        print(json.dumps(first_record, ensure_ascii=False, indent=2))

data_provider/m4.py

@@ -0,0 +1,141 @@
+# 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)
+        m4dataset = 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))
+        # import pdb
+        # pdb.set_trace()
+        return m4dataset
+
+
+@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)

data_provider/uea.py

@@ -0,0 +1,125 @@
+import 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

dataset/m4/Daily-train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78e94591c60c06309f1e544fd7b2ccba28f3616b01913dd336a1d1d98483a1ec
+size 95765153

dataset/m4/Monthly-train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63aaa56198b4a22279a2fec541f56921f3bed6d8e0f84e550206df9276f2e9b9
+size 91655432

dataset/m4/Quarterly-train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4450678cd493aa965c14bde984a5b62a66d8c3b2f7af1e53779bc91ff008ccdc
+size 38788547

dataset/m4/Weekly-test.csv

@@ -0,0 +1,360 @@
+"V1","V2","V3","V4","V5","V6","V7","V8","V9","V10","V11","V12","V13","V14"
+"W1","35397.16","35808.59","35808.59","36246.14","36246.14","36403.7","36403.7","36150.2","36150.2","35790.55","35790.55","34066.95","34066.95"
+"W2","3608.061","3624.368","3537.64","3587.344","3662.088","3658.634","3622.148","3591.48","3638.559","3635.781","3522.328","3458.631","3354.758"
+"W3","9602.4","9895.9","9915.9","9726.6","9626.5","9966.1","10008.5","9911.7","9760.7","9968.2","10089.1","10005.9","9823.3"
+"W4","2336.56","2373.14","2457.51","2586","2237.7","2877.94","2497.74","3525.34","3053.33","3151.07","3425.79","3505.61","4098.69"
+"W5","1499","1734","1391","1833","1637","2122","1757","2079","2477","1957","1907","1752","1330"
+"W6","502","568","528","632","606","785","779","834","906","1372","1080","938","752"
+"W7","3117","2579","3199","1716","4558","3001","3263","3110","5899","7148","4048","2707","2579"
+"W8","3430","2870","4620","4890","7470","6960","6430","3970","3650","5730","4500","2870","3270"
+"W9","8100","7481","8953","8087","9724","8993","10011","9705","8397","7560","8669","7574","7106"
+"W10","5122.14","5104.68","5104.68","5104.68","5565.7","5565.7","5565.7","5565.7","5565.7","5544.94","5544.94","5544.94","5544.94"
+"W11","337.19","359.52","357.62","368.22","328.77","391.31","340.06","323.19","323.3","339.94","316.45","295.99","280.07"
+"W12","1092","1085","1078","1071","1064","1057","1050","1043","1092","1085","1078","1071","1064"
+"W13","2373.445","2373.105","2453.974","2390.353","2324.83","2337.239","2375.971","2398.802","2350.108","2363.517","2484.652","2558.814","2653.311"
+"W14","2341.516","2407.573","2435.3","2361.92","2310.927","2322.117","2408.718","2476.214","2361.203","2393.436","2552.503","2554.351","2500.651"
+"W15","4231","4311.68","3848.09","4149.38","3633.49","3553.49","3743.59","4626.91","4235.48","4288.81","5601.72","5737.57","5232.13"
+"W16","4231","4311.68","3848.09","4149.38","3633.49","3553.49","3743.59","4626.91","4235.48","4288.81","5601.72","5737.57","5232.13"
+"W17","12027.16","12027.2","12027.24","11985.62","11985.74","12432.86","12432.99","12418.26","12418.32","12418.37","12418.43","12418.49","12323.22"
+"W18","4334.57","4334.61","4334.65","4351.65","4351.77","3846.99","3954.85","3996.48","3992.55","3992.61","3992.68","3992.75","4029.96"
+"W19","2754","3035","2591","2808","2324","4033","3146","3402","3677","4790","7520","4445","2960"
+"W20","3942","4184","3374","4291","2657","4258","4050","3730","3311","3154","4551","4677","3944"
+"W21","2203","2234","1786","2582","2838","2949","2483","2184","3809","3395","3194","2744","2054"
+"W22","3780","4430","3380","4100","2710","3980","3720","3300","3460","2760","4730","3930","3180"
+"W23","753.8","767.6","722.9","769.5","536.6","756.4","813","732.2","617.9","617","901.1","872.9","739.2"
+"W24","6510","6109","5215","6798","4354","10041","7637","6137","7002","8575","19189","12646","6956"
+"W25","1431","1679","1348","1870","2110","2492","2701","2649","2745","2676","3017","2669","2017"
+"W26","2672","3061","2947","4293","3409","4660","5136","6235","5580","4585","6168","4943","3945"
+"W27","2144","2144","1752","2314","2645","2643","3120","3302","3802","2762","3713","4473","2643"
+"W28","7793","3341","3003","3507","2555","3167","3300","3507","8089","8507","5611","4081","3025"
+"W29","851","1017","907","1075","833","1716","1339","1312","1345","1322","2142","1732","1143"
+"W30","3623","4016","3075","4373","3773","5121","4129","4785","6509","7561","6183","5485","4223"
+"W31","708","829","796","1026","1483","1412","1665","1696","2150","1948","1778","1156","1053"
+"W32","5029","3990","5803","3980","6833","5247","6023","7372","6529","7042","6642","6607","7307"
+"W33","1635.1","1470","1831.2","1860.7","2952.6","2076","1926.5","2127.6","2526.5","3130.5","2901.6","1965.4","1930.4"
+"W34","1528","1485","1676","1434","2556","2017","1752","1575","1478","2618","2045","1480","1464"
+"W35","1240","938","1641","1225","2143","2298","1561","1253","1257","2191","2137","1662","1565"
+"W36","18469.2","14697.3","14490.1","16890.6","13307.5","11488","11021.4","13786","17773.2","20125.2","13053.1","14418.3","18561.2"
+"W37","2891.8","2870","2839.7","2925.6","2858.2","2873.3","2857.3","2832.8","2818.5","2843","2863.1","2838.6","2827.4"
+"W38","3050.13","2991.26","2966.63","3079.93","3027.55","3046.13","3052.31","3028.4","3042.15","3060.21","3044.19","3005.94","2999.31"
+"W39","5820.04","5811.86","5764.85","5774.63","5782.51","5729.81","5736.21","5784.8","5783.06","5742.76","5732.81","5730.19","5678.13"
+"W40","5816.795","5807.545","5761.31","5766.93","5777.23","5727.54","5732.42","5780.82","5776.885","5739.61","5732.305","5721.025","5674.69"
+"W41","6138.53","6046.39","6014.57","6020.12","6111.92","6065.35","6090.68","6170.24","6206.4","6161.53","6092.33","6028.87","6039.88"
+"W42","6145.38","6055.38","6021.96","6036.22","6123.1","6070.16","6098.74","6178.74","6219.68","6168.3","6093.4","6048.22","6047.21"
+"W43","6141.955","6050.885","6018.265","6028.17","6117.51","6067.755","6094.71","6174.49","6213.04","6164.915","6092.865","6038.545","6043.545"
+"W44","5813.55","5803.23","5757.77","5759.23","5771.95","5725.27","5728.63","5776.84","5770.71","5736.46","5731.8","5711.86","5671.25"
+"W45","2934.68","2967.95","3071.57","3101.51","3101.51","3136.93","3189.06","3165.62","3069.02","2990.9","2965.64","2997.27","3001.98"
+"W46","3156.835","3088.77","3129.65","3163.045","3114.31","3110.356","3123.937","3136.711","3158.378","3095.771","3042.689","3026.794","3062.599"
+"W47","2933.38","2967.36","3070.66","3098.73","3098.73","3134.37","3186.88","3164.56","3067.65","2988.52","2963.47","2994.78","2999.43"
+"W48","2964.555","2996.025","3000.705","2941.08","2935.96","2938.24","2936.72","2936.66","2882.2","2862.63","2867.64","2875.68","2871.67"
+"W49","3193.28","3248.07","3406.28","3378.86","3335.78","3331.52","3375.54","3365.51","3264.59","3155.58","3087.64","3128.35","3161.7"
+"W50","3194.69","3248.72","3407.29","3381.89","3338.78","3334.24","3377.85","3366.64","3266.05","3158.09","3089.9","3130.95","3164.39"
+"W51","6549.4","6749.6","6672.9","6664.1","6601.3","6601.8","6483.1","6488.7","6431.8","6468.2","6418.9","6383.5","6403.6"
+"W52","6980.8","7049.9","6985.1","7060.9","7021.9","7015","6921.2","6940.5","6942","6894.3","6783.9","6801.8","6773.4"
+"W53","1915.5","1845.1","1867.4","2142","2309.8","2248.6","2182.6","2050.6","1986.8","1865.6","1912.3","1982.7","1933.5"
+"W54","2483","2491","2474","2491","2483","2460","2473","2448","2429","2411","2434","2445","2439"
+"W55","5056","4936","4551","4461","4515","4725","4863","5097","5191","5195","5328","5342","5207"
+"W56","3030","3099","3193","3261","3334","3440","3538","3633","3733","3814","3877","3929","3978"
+"W57","2070","1970","1830","1730","1640","1550","1500","1460","1460","1390","1370","1370","1410"
+"W58","3485","3651","3681","3704","3737","3907","3747","3820","3842","3649","3414","3116","2984"
+"W59","2350","2040","2030","1600","1160","2140","2780","1910","2180","2170","2010","1690","1880"
+"W60","9160.47","9180.81","9257.59","9244.22","9195.97","9383.28","9480.43","9506.87","9431.19","9450.03","9630.17","9660.81","9601.98"
+"W61","10128.3","10802.8","10802.8","10971.1","10971.1","10436.8","10436.8","11025.5","11025.5","10135.8","10135.8","10934.7","10934.7"
+"W62","7208.8","7061.6","7061.6","7018.9","7018.9","7157.6","7157.6","7144.4","7144.4","7536.5","7536.5","7620.1","7620.1"
+"W63","6062.1","6110.6","6110.6","6119.9","6119.9","6115.9","6115.9","6194.7","6194.7","6386.4","6386.4","6649.3","6649.3"
+"W64","14834","12734","12772","13825","15080","12824","12879","13769","14767","13645","12832","13629","15073"
+"W65","20461","17999","18027","19270","20726","18118","18144","19242","20438","19136","18135","19163","20871"
+"W66","7318.7","7580.2","7605.2","7418.2","7320.8","7633.4","7663.4","7564.1","7418.4","7616","7729","7645","7464.2"
+"W67","13361","13641","13485","13635","13869","13787","13846","13810","13958","13995","13987","14185","14413"
+"W68","6925.91","6949.42","6997.28","7002.45","6998.8","6970.53","7019.43","7039.14","7041.96","6974.79","6967.61","6968.64","6957.49"
+"W69","6930.32","6983.87","7009.79","7004","7003.5","6971.28","7036.53","7049.97","7035.15","6965.37","6967.94","6962.49","6960.41"
+"W70","2612.74","2607.29","2583.84","2601.24","2597.5","2591.6","2648.13","2649.71","2654.19","2655.63","2614.58","2613.64","2614.93"
+"W71","1930","1927","1927","1907","1906","1903","1903","1902","1897","1897","1896","1893","1892"
+"W72","1930","1927","1927","1907","1906","1903","1903","1902","1897","1897","1896","1893","1892"
+"W73","1930","1927","1927","1907","1906","1903","1903","1902","1897","1897","1896","1893","1892"
+"W74","4494.5","3936.22","4013.09","3951.31","3701.88","3380.45","3652.31","3893.49","4156.82","4353.71","4927.72","5405.49","6528.25"
+"W75","23442.9","23935.8","24274.4","23870.6","23235.6","23930.5","25498.8","25416.7","23773.6","25931.8","25269.5","24984.5","25674.5"
+"W76","440","440","440","440","440","440","440","440","240","240","240","240","240"
+"W77","3977.66","4541.82","5291.64","4690.9","4198.24","4610.46","4725.98","4681.88","3926.7","3826.87","4457.07","4650.71","4440.09"
+"W78","3923.9","4525.96","5268.49","4149.73","4106.37","4300.7","4930.68","4726.57","3929.57","4190.49","4428.39","4249.56","4221.58"
+"W79","1560","1720","1770","1820","1860","1930","1790","1660","1620","1600","1590","1640","1670"
+"W80","1720","1760","1810","1840","1950","1820","1670","1620","1600","1580","1640","1660","1760"
+"W81","23057.9","24044.6","23942.2","23970.5","23519","23811.9","24756.7","24982.2","24388.4","24379.1","25518.2","24728","25659.7"
+"W82","4417.421","4434.675","4430.035","4412.757","4414.728","4419.787","4422.151","4410.932","4409.458","4417.371","4423.566","4427.224","4414.39"
+"W83","6001.5","5974.5","5931.6","6028.6","6053","6064","6017.2","5972.1","5997.6","5991.1","5939.8","5939.5","5940.6"
+"W84","6016.7","5923.8","5945","6050.1","6069.5","6022.3","5944.7","5985.6","5996","5978","5937.4","5937.5","5944"
+"W85","17289","17312","17335","17364","17429","17501","17567","17632","17683","17718","17753","17791","17808"
+"W86","17297","17320","17344","17385","17454","17522","17601","17661","17696","17731","17766","17801","17791"
+"W87","1094.56","1094.52","1092.83","1091.55","1098.78","1099.02","1096.83","1093.89","1089.57","1099.3","1098.45","1095.05","1088.79"
+"W88","12154.01","12042.04","12027.43","11998.81","12089.79","12025.85","12079.76","12053.18","12179.34","12133.8","12093.14","12163.75","12117.78"
+"W89","1185.62","1180.63","1201.97","1132.26","1087.99","1095.31","1151.72","1115.15","1107.33","1089.42","1084.26","1103.96","1071.63"
+"W90","1828.128","1861.782","1872.236","1854.954","1852.089","1854.091","1868.669","1893.618","1859.457","1860.784","1871.368","1829.142","1818.838"
+"W91","19466.9","19798.45","19924.33","19681.8","19608.88","19636.22","19838.41","20051.33","19701.9","19697.26","19797.94","19395.38","19260.01"
+"W92","21837.03","22832.08","22198.61","22399.36","22658.55","22969.77","22908.66","22311.88","21853.35","22670.54","22686.31","21102.33","21032.34"
+"W93","1748.563","1753.833","1740.646","1741.955","1753.649","1760.835","1747.62","1745.674","1751.342","1758.483","1747.428","1749.617","1753.035"
+"W94","1802.54","1986.53","1931.14","1831.39","1948.19","1948.12","2000.27","2077.83","2068.5","2093.54","2174.32","2052.07","2108"
+"W95","1621.22","1764.77","1679.71","1638.8","1728.67","1733.06","1799.69","1857.32","1899.37","1907.46","1936.32","1863.71","1912.86"
+"W96","11355.272","11385.864","11303.634","11309.627","11397.101","11427.142","11459.31","11388.745","11451.752","11478.884","11545.812","11497.115","11568.007"
+"W97","447.83","454.85","482.02","472.14","455.09","481.15","524.38","519.49","485.51","467.8","486.97","483.66","457.56"
+"W98","584.3","590.59","610.91","597.94","585.15","610.26","651.93","646.63","617.37","598.04","617.17","615.46","586.87"
+"W99","14837.74","14751.79","14883.29","15009.8","14963.45","14930.14","14847.66","14828.55","14864.72","14893.35","14811.6","14898.23","14855.39"
+"W100","11474.49","11875.5","11517.02","11305.8","11423.14","11647.5","11632.38","11729.89","11679.04","11740.51","11934.32","11741.1","11634.37"
+"W101","9871.498","9910.685","9815.305","9808.647","9900.756","9934.128","9974.544","9905.89","9965.28","9989.549","10064.652","10007.292","10082.468"
+"W102","16004.79","15859.41","15729.3","15616.87","15749.81","15642.21","15716.89","15789.79","15961.13","15986.34","15871.65","15813.95","15743.94"
+"W103","4153.94","4375.42","4063.47","3975.35","4202.22","4212.67","4171.08","4025.43","4260.1","4159.33","4272.43","3968.74","3905.78"
+"W104","1026.84","1019.01","1009.31","1003.54","1007.61","1004.8","998.68","991.28","991.98","988.73","979.2","976.82","968.28"
+"W105","9135.8","9155.8","9123.07","9168.48","9097.38","9109.48","9061.98","9058.14","9033.5","9064.66","9038.48","9025.31","9001.11"
+"W106","2162.966","2167.806","2153.199","2154.003","2164.848","2171.359","2157.906","2154.995","2160.496","2165.439","2154.43","2155.905","2159.078"
+"W107","24019.73","23983.72","24168.42","24240.09","24481.23","24419.29","24441.25","24333.51","24398.35","24222.27","24359.23","24297.26","24345.73"
+"W108","15926.84","16078.017","15963.238","15970.428","16056.811","16086.342","16092.328","16042.099","16027.739","16096.719","16115.75","15955.488","15951.666"
+"W109","14171.645","14318.713","14198.442","14206.103","14300.423","14334.406","14340.354","14293.978","14288.988","14354.158","14370.531","14207.81","14198.367"
+"W110","7331.84","7307.69","7396.85","7438.91","7519.81","7592.29","7571.98","7464.36","7484.2","7484.94","7528.27","7483.09","7522.26"
+"W111","1080.57","1080.53","1078.63","1077.26","1084.46","1084.89","1082.71","1079.78","1076.06","1085.53","1084.67","1081.1","1074.27"
+"W112","9609.45","9520.42","9512.01","9471.4","9562.31","9488.15","9556.86","9534.86","9647.41","9594.13","9576.58","9662.18","9644.83"
+"W113","754.7","766.1","766.27","714.66","682.99","700.3","763.74","747.68","742.31","717.41","712.44","734.81","726.45"
+"W114","10463.22","10370.99","10322.48","10331.1","10275.58","10318.71","10216.97","10282.47","10238.62","10071.88","10200.06","10227.22","10233.33"
+"W115","11217.92","11137.09","11088.75","11045.76","10958.57","11019.01","10980.71","11030.15","10980.93","10789.29","10912.5","10962.03","10959.78"
+"W116","14539.1","14894.1","13984.77","13907.03","14293.59","14685.26","15017.67","14100.07","14408.13","14676.51","15205.38","13875.72","14094.91"
+"W117","7037.56","7043.25","7026.12","7062.94","7075.16","7057.07","7064.06","7097.6","7249.93","7267.89","7328.08","7388.03","7480.86"
+"W118","1747.852","1753.13","1739.954","1741.265","1752.962","1760.145","1746.934","1744.992","1750.66","1757.801","1746.75","1748.939","1752.358"
+"W119","1029.75","1180.41","1140.58","1060.38","1154.44","1152.64","1175.8","1244.19","1225.38","1262.37","1332.13","1221.9","1270.41"
+"W120","855.09","989.28","916.28","889.25","943.99","943.1","996.81","1044.71","1069.8","1090.56","1126.05","1064.67","1106.98"
+"W121","10465.971","10496.016","10403.031","10399.53","10497.08","10528.68","10569.283","10488.464","10554.103","10585.971","10651.968","10589.396","10672.134"
+"W122","329.99","321.94","332.45","333.74","338.72","353.4","396.27","383.57","366.9","359.23","363.53","378.46","369.19"
+"W123","440.2","431.45","435.3","432.77","440.92","454.74","497.32","484.31","473.21","461.88","466.64","483.21","471.99"
+"W124","8434.6","8404.06","8370.62","8440.35","8445.77","8485.14","8424.83","8351.47","8365.51","8411.94","8472.83","8434.49","8421.44"
+"W125","10927.21","11218.64","10974.46","10771.82","10862.93","11054.22","11031.79","11089.91","11069.27","11163.08","11300.69","11152.85","11055.06"
+"W126","9622.511","9655.61","9565.969","9555.495","9652.503","9680.166","9726.8","9653.317","9717.552","9744.777","9804.685","9745.947","9829.99"
+"W127","11173.39","10918.46","10850.02","10756.78","10815.1","10764.33","10842.66","10886.6","10968.92","11026.69","11039.92","11213.69","11323.96"
+"W128","3659.91","3836.54","3603.72","3518.12","3731.7","3682.25","3703.91","3552.16","3731.15","3699.87","3741.75","3541.9","3452.87"
+"W129","1007.32","1000.05","990.76","985.07","988.6","986.32","981.23","974.06","974.39","971.47","961.91","960.25","951.77"
+"W130","8142.17","8164.91","8155.02","8197.46","8121.84","8135.96","8115.75","8106.23","8078.34","8105.2","8077.74","8059.49","8032.97"
+"W131","2161.865","2166.713","2152.117","2152.923","2163.772","2170.279","2156.83","2153.923","2159.431","2164.374","2153.369","2154.844","2158.018"
+"W132","22735.69","22695.8","22873.78","22912.73","23157.6","23052.45","23109.41","23066.29","23133.89","22943.61","23070.07","23056.38","23135.75"
+"W133","13883.352","13943.084","13817.27","13799.658","13890.442","13929.041","13978.179","13895.258","13956.526","13983.295","14057.238","13958.295","14011.606"
+"W134","12132.819","12188.302","12057.06","12039.798","12138.491","12181.638","12230.64","12151.594","12222.102","12245.022","12316.353","12215.006","12262.678"
+"W135","6190.89","6166.87","6248.29","6256.87","6346.31","6377.59","6382.05","6333.99","6350.53","6326.36","6362.01","6363.97","6432.69"
+"W136","6432.1","6492.9","6523.6","6596.4","6759.9","6701.7","6745.7","6721.2","6644","6667.8","6661.7","6458.5","6508.5"
+"W137","7126.057","7071.44","7078.15","7037.05","7071.02","7029.9","7096.12","7087.92","7166.37","7130.38","7131.41","7203.06","7162.08"
+"W138","387.13","396.14","404.7","363.68","322.02","328.5","392.13","382.78","364.21","339.84","334.59","363.64","337.18"
+"W139","7833.402","7763.08","7697.07","7691.19","7674.28","7754.88","7648.39","7689.17","7639.02","7478.78","7613.66","7563.24","7531.5"
+"W140","8220.532","8159.22","8101.77","8054.87","7996.3","8083.38","8040.52","8071.95","8003.23","7818.62","7948.25","7926.88","7868.68"
+"W141","10971.829","11241.17","10370","10322.61","10592.83","10873.84","11160.36","10316.67","10680.77","10809.59","11455.11","10315.26","10644.41"
+"W142","5388.424","5388.93","5368.95","5390.96","5401.97","5389.98","5392.11","5412.92","5525.45","5540.92","5580.59","5622.11","5684.54"
+"W143","11374.106","11419.08","11304.46","11312.03","11412.35","11481.37","11381.15","11365.37","11386.84","11445.25","11290.92","11301.3","11310.58"
+"W144","1005.48","1152.75","1113.19","1035.17","1124.86","1122.3","1147.56","1215.37","1191.06","1226.87","1298.58","1187.11","1237.65"
+"W145","8345.9","9654.6","8929.2","8681.6","9187.9","9169.4","9726.4","10199.3","10397.5","10589.6","10966.5","10340.4","10782"
+"W146","6801.5412","6826.213","6737.471","6733.834","6810.25","6824.878","6855.421","6783.048","6832.483","6856.145","6914.958","6859.368","6934.528"
+"W147","120.66","117.59","111.32","110.66","110.46","111.68","120.32","117.41","125.32","121.24","112.52","122.99","118.27"
+"W148","222.63","218.63","205.95","201.16","204.31","204.6","212.82","209.47","223.37","215.24","206.88","219.05","212.55"
+"W149","4374.969","4342.37","4303.19","4370.16","4392.91","4423.87","4362.98","4303.89","4317.18","4359.9","4426.36","4381.17","4372.66"
+"W150","8104.576","8397.21","8157.4","7991.08","8073.41","8245.39","8235.18","8301.8","8245.5","8365.11","8466.19","8322.25","8219.59"
+"W151","6364.0443","6391.976","6307.152","6296.818","6370.959","6382.491","6419.123","6352.659","6400.765","6420.155","6472.322","6421.251","6497.262"
+"W152","8624.177","8443.2","8390.94","8266.24","8299.13","8283.85","8356.8","8416.68","8466.06","8541.06","8572.49","8732.67","8749.33"
+"W153","2990.33","3154.84","2945.55","2862.16","3032.25","2990.3","3001.65","2879.11","3049.37","2997.1","3046.23","2862.51","2802.91"
+"W154","8643.9","8597.8","8504.5","8468.7","8454","8415","8361.8","8296.2","8313.1","8300.7","8219.2","8228.2","8136.1"
+"W155","4568.001","4591.74","4592.62","4636.82","4562.67","4572.28","4557.9","4538.75","4523.75","4521.02","4499.58","4485.14","4473.5"
+"W156","5432.391","5451.52","5443.07","5483.69","5408.07","5413.78","5394.08","5368.37","5355.06","5351.09","5321.5","5307.96","5287.11"
+"W157","1431.923","1435.919","1422.959","1423.154","1432.548","1438.745","1428.38","1425.897","1427.808","1431.297","1415.852","1416.006","1416.477"
+"W158","16585.796","16545.69","16718.18","16774.2","16973.97","16859.12","16888.19","16801.33","16854.51","16677.41","16792.37","16756.94","16839.65"
+"W159","9265.8308","9320.682","9198.628","9181.263","9248.034","9273.226","9311.038","9229.568","9282.625","9295.202","9366.068","9272.725","9316.549"
+"W160","8060.0957","8112.114","7987.147","7969.756","8043.952","8072.951","8110.896","8034.681","8093.054","8099.825","8169.184","8075.646","8114.811"
+"W161","12143.281","12130.04","12220.91","12262.51","12368.93","12230.26","12271.89","12244.95","12279.44","12134.14","12219.63","12187.07","12201.34"
+"W162","4442.515","4415.65","4497.27","4511.69","4605.04","4628.86","4616.3","4556.38","4575.07","4543.27","4572.74","4569.87","4638.31"
+"W163","3806.6","3812.9","3801.8","3787","3826","3831.2","3817.2","3802.3","3799.9","3852","3840.2","3822.6","3798.4"
+"W164","24833.93","24489.8","24338.6","24343.5","24912.9","24582.5","24607.4","24469.4","24810.4","24637.5","24451.7","24591.2","24827.5"
+"W165","3675.7","3699.6","3615.7","3509.8","3609.7","3718","3716.1","3649","3781","3775.7","3778.5","3711.7","3892.7"
+"W166","2629.818","2607.91","2625.41","2639.91","2601.3","2563.83","2568.58","2593.3","2599.6","2593.1","2586.4","2663.98","2701.83"
+"W167","2997.388","2977.87","2986.98","2990.89","2962.27","2935.63","2940.19","2958.2","2977.7","2970.67","2964.25","3035.15","3091.1"
+"W168","3567.271","3652.93","3614.77","3584.42","3700.76","3811.42","3857.31","3783.4","3727.36","3866.92","3750.27","3560.46","3450.5"
+"W169","1649.136","1654.32","1657.17","1671.98","1673.19","1667.09","1671.95","1684.68","1724.48","1726.97","1747.49","1765.92","1796.32"
+"W170","3593.378","3600.1","3605.11","3626.18","3631.12","3625.32","3631.86","3645.91","3674.92","3680.2","3698.89","3719","3754.53"
+"W171","6104.414","6112.22","6095.08","6100.62","6117.27","6120.08","6088.19","6084.55","6119.76","6132.76","6176.58","6188.09","6213"
+"W172","3664.4298","3669.803","3665.56","3665.696","3686.83","3703.802","3713.862","3705.416","3721.62","3729.826","3737.01","3730.028","3737.606"
+"W173","3696.3","3536.5","3504.4","3481.7","3684.6","3749.7","3684.8","4354.7","3618.1","4381.4","3985.8","3381.9","3209.2"
+"W174","2822.634","2821.43","2817.06","2780.74","2789.52","2808.83","2796.61","2788.11","2823.77","2797.97","2834.5","2830.6","2835.47"
+"W175","3258.4667","3263.634","3258.817","3258.677","3281.544","3297.675","3307.677","3300.658","3316.787","3324.622","3332.363","3324.696","3332.728"
+"W176","2549.213","2475.26","2459.08","2490.54","2515.97","2480.48","2485.86","2469.92","2502.86","2485.63","2467.43","2481.02","2574.63"
+"W177","6695.8","6817","6581.7","6559.6","6994.5","6919.5","7022.6","6730.5","6817.8","7027.7","6955.2","6793.9","6499.6"
+"W178","1429.3","1402.7","1403.1","1382","1432","1448.2","1450.5","1444.4","1430.8","1414","1399.9","1374.3","1381.6"
+"W179","2709.779","2713.39","2711.95","2713.77","2713.77","2722.18","2721.67","2737.86","2723.28","2754.11","2756.24","2751.53","2745.86"
+"W180","7299.42","7307.94","7291.58","7297.69","7312.24","7315.34","7284.5","7280.26","7316.23","7330.77","7375.17","7388.38","7415.41"
+"W181","8859.673","8863.5","8867.55","8852.3","8897.4","8915.51","8942.89","9002.82","9002.66","9020.31","9033.94","9050.97","9041.96"
+"W182","1375.3","1376.8","1377.8","1382.1","1392.3","1392.1","1472.6","1476.2","1488.5","1487.9","1491.4","1494.2","1492.8"
+"W183","6149.894","6150.11","6155.6","6138.53","6183.63","6193.33","6221.22","6264.96","6279.38","6266.2","6277.7","6299.44","6296.1"
+"W184","4617.5212","4622.402","4618.642","4618.395","4642.408","4655.815","4667.141","4665.69","4673.901","4688.093","4691.17","4685.57","4695.057"
+"W185","4072.7233","4076.188","4069.913","4070.042","4094.539","4108.687","4119.744","4116.913","4129.048","4145.197","4147.169","4139.36","4147.867"
+"W186","1748.375","1751.22","1751.02","1745.18","1741.27","1748.73","1765.75","1777.61","1775.46","1783.09","1789.27","1794.1","1794.38"
+"W187","942.8","948.4","944.3","940.1","945.4","960","936.4","939.7","939.3","934.4","920.4","913.7","937.7"
+"W188","2235","2247","2197","2225","2192","2240","2149","2191","2159","2176","2252","2201","2227"
+"W189","2128","2141","2165","2108","2221","2365","2180","2244","2272","2246","2038","1965","2069"
+"W190","456.6855011","460.7204403","453.8686316","441.8651676","445.577063","453.0822772","437.6623557","439.8819108","430.3451587","426.0420738","419.6364978","411.3800853","418.5663313"
+"W191","6635.2293","6711.3531","6879.4553","7031.4599","7280.6471","7287.6782","7199.4766","7075.0888","7495.1075","7853.2658","7738.1914","7432.3491","7384.1148"
+"W192","1160.330918","1165.783708","1130.218848","1144.012678","1116.237318","1143.744038","1056.720308","1119.294178","1064.618758","1048.372548","1135.591008","1105.256478","1120.579848"
+"W193","5897.9498","5780.9284","5693.2279","5734.5912","5836.8002","5884.0807","5840.0028","5820.8905","5977.0669","6176.512","6055.0658","6023.6219","6056.9425"
+"W194","483.26481","501.30087","495.69513","505.966605","490.018459","506.016419","506.059303","488.243623","494.494998","507.554868","508.900208","491.403635","498.588915"
+"W195","984.43264","1007.22011","977.57691","956.13304","989.18684","978.19025","972.65437","932.85298","995.85932","965.36357","978.65649","978.76934","995.1377"
+"W196","9829.0437","9985.4137","10293.6715","10359.0839","9848.4779","9843.3371","9851.5289","10083.1847","9901.8945","10063.8348","9912.0124","9947.1883","10295.3118"
+"W197","3349.318574","3535.511928","3464.898719","3501.769843","3412.296678","3438.179535","3346.9989","3340.722945","3385.474665","3372.953029","3373.89518","3370.010094","3361.798917"
+"W198","2494.02866","2504.633975","2516.196395","2459.919613","2562.934537","2680.654134","2526.370987","2563.657085","2549.711739","2523.642748","2295.089991","2323.388696","2404.942722"
+"W199","853.411584","717.379492","739.09963","715.596157","753.511419","764.419871","759.384134","791.933924","759.283655","774.301921","848.021256","804.524732","889.772763"
+"W200","1847.36095","1741.76012","1857.16426","1737.89313","1834.76119","1945.47024","1795.47817","1859.5506","1993.599","1853.21632","1763.33719","1134.09872","1700.70876"
+"W201","1967","2006","2007","1992","1974","1963","1958","1941","1986","1972","1970","1973","2025"
+"W202","4203","4253","4204","4217","4166","4203","4106","4133","4145","4147","4222","4175","4252"
+"W203","5510","5380","5370","5260","5250","5110","5260","5050","4770","4630","4340","4720","5060"
+"W204","7304","7318.9","7362.3","7295.9","7296.4","7304.9","7339.5","7345.8","7326.6","7325.2","7360.2","7382.9","7378.7"
+"W205","12491.95","13013.34","13209.75","12981","13537.85","13132.64","13691.5","13967.95","13867.98","13856.59","14381.13","14510.66","14226.31"
+"W206","1050.5","1093.4","1222","1223.7","1043.1","930.1","1070.1","1341","966.5","1052.4","938.6","1193.9","1217.3"
+"W207","11744.3","11322.8","11200.7","12733.5","14568.8","20567.8","16736.3","13883.6","13380.5","13299.4","15151.2","14482.4","14773.8"
+"W208","29018.3","25380.9","24903.8","27184.9","23801.6","22076","21381.2","24022.8","28176.7","30520","23750.7","25196.6","29393"
+"W209","4185.45","4185.45","4185.45","4185.45","4185.45","3944.18","3944.18","3944.18","3944.18","3944.18","3944.18","3944.18","3944.18"
+"W210","8204.21","8496.79","8690.18","8796.65","9308.62","8889.88","9285.78","9353.08","9523.59","9788.87","9638.59","9552.7","9535.58"
+"W211","19138.99","19322.67","19505.88","19671.03","19823.39","19748.99","19869.76","20103.52","20304.31","20497.56","20640.15","20839.37","21017.61"
+"W212","5461.05","5465.87","5464.51","5474.37","5898.01","5958.73","5908.25","5890.65","5889.96","5886.71","5863.1","5846.83","5831.24"
+"W213","3232.2","3400.7","3606","3686.4","3553.5","3071.9","3189.4","3471.8","3135.3","3578.1","3467.9","3637.1","3466"
+"W214","1824.5","1743.9","1794","1809.4","1827.3","1908.2","1847","1751.8","1898.1","1880.5","1978.2","1886.8","1902.4"
+"W215","2366.43","2369.53","2390.59","2419.53","2406.42","2491.02","2478.39","2482.26","2470.39","2449.71","2447.86","2447.49","2469.36"
+"W216","3140.68","3143.77","3165.33","3194.56","3177.71","3278.54","3265.51","3269.02","3257.17","3236.28","3234.39","3231.67","3247.35"
+"W217","9877.09","9890.943","9890","9800","9897","9700","9000","9700","9907.7","9907","9700","9910","9900"
+"W218","9932.821","9936.393","9000","9700","9943","9700","9940.001","9700","9948.552","9951.79","9000","9945","9000"
+"W219","1091","1084","1077","1070","1063","1056","1092","1085","1078","1071","1064","1057","1050"
+"W220","1820","1813","1806","1799","1792","1785","1820","1813","1806","1799","1792","1785","1778"
+"W221","7743.8","7448.1","6802.5","6961.8","7160.7","7338.7","6925.2","7142.4","7651.6","7691.4","7589.4","7706.7","7590.4"
+"W222","7727.1","7515.8","7002.1","7245.4","7361.2","7562.2","7879.1","8082.1","8025.9","8605","8503.5","8405.7","8763.5"
+"W223","26994","26695","28522","27712","27511","27231","27409","27856","27639","26848","27687","27342","27494"
+"W224","1706.741","1739.879","1741.962","1763.156","1740.79","1857.234","1746.231","2071.371","1997.189","2097.67","2111.099","2253.543","2460.929"
+"W225","1930.9","1929.5","1958.5","1935.1","1926.6","2119.8","1982.7","2016.5","2039.6","2311.4","2792.7","2319.2","2147.7"
+"W226","2865.2","2798.5","2576.4","2805.7","2486","2628.3","2494.4","2560.8","2487.5","2543","2524.4","2603.3","2591.2"
+"W227","1365.7","1392.9","1389.1","1439.9","1431.2","1665.4","1561.1","1606.1","1570.6","1804.3","1935.1","1801.3","1744.1"
+"W228","8171","8157","8180","8378","8086","8624","8408","8643","8586","8856","8908","9137","8873"
+"W229","465.53","438.43","443.29","443.83","391.38","476.51","405.11","448.58","416.24","441.32","428.96","432.6","449.93"
+"W230","3117.6","2928.4","2783.4","2987.1","2533.1","3403.5","3054.5","3060.2","3022.7","3426.2","4886.7","4280.2","3533.6"
+"W231","599.6","646.8","672","706.3","755.7","899.6","917.3","1036.2","1119.2","1283","1384.5","1475.1","1504.4"
+"W232","1880.4","1889.2","1864.5","1961.1","2009.7","2211.1","2235","2421.8","2774","3052","3018.4","3171.4","3206.1"
+"W233","1036.6","1036.6","994","1040.9","1024.8","1199.4","1106.1","1197.6","1296","1448.2","1485.5","1600.9","1695"
+"W234","2117","1891.1","2178.6","1910.3","1818.5","1984.8","1958.6","1953.1","2009.7","2158.7","2640.2","2550.4","2678.7"
+"W235","434.3","451.5","493.3","532.4","535.7","647.1","661.3","710.3","763.1","827.1","937.4","1003","1010.4"
+"W236","3265.2","3299.2","3276.9","3338.6","3299.6","3574.8","3557.3","3591.5","3690.3","3977.2","4463.9","4347","4358.4"
+"W237","1070.7","1079","1034.4","1099.3","1055.1","1200.8","1155.9","1202.1","1206.6","1378.2","1438.1","1340.1","1262.4"
+"W238","430","420.4","399.8","415.2","435.7","548.9","538","631.4","714.5","831.1","925.2","953","917.2"
+"W239","3696","3792","3780","3928","3927","4330","4349","4500","4765","5057","5945","5664","5722"
+"W240","2586.5","2560.4","2776.9","2698.6","3157.7","2938.2","3040.8","3197.8","3367.8","3726.5","3724","3796.8","3728.7"
+"W241","1040.84","1015","1098.25","1031.9","1168.21","1271.09","1311.2","1252.43","1363.56","1496.95","1592.62","1614.64","1511.61"
+"W242","1475.3","1468.6","1494.2","1447.2","1643.9","1534.3","1587.3","1580.3","1927.1","2321.8","1935.5","1728.8","1741.4"
+"W243","1245","1330","1551","1550","2150","2514","2855","3230","3335","3511","3890","3812","3828"
+"W244","806.8","841.6","883.8","914.1","988.6","1108","1183","1226.4","1258","1325.9","1434.3","1480.2","1488.3"
+"W245","2291.2","2266.7","2332","2266.8","2538.8","2482.1","2508.7","2508.2","2705.3","2972.8","3072.2","3059","2984.6"
+"W246","1138.7","1098","1159.8","1136.4","1476.2","1476.6","1385.7","1392.2","1435.2","1579.6","1807.3","1769.8","1686.5"
+"W247","4410.5","4581.6","4723.5","4791.8","5421","5510.5","5612.2","5829.8","6084.9","6239.6","6659.6","6860.6","6854.3"
+"W248","16190.4","16913.4","16913.4","17091","17091","16552.7","16552.7","17220.2","17220.2","16522.2","16522.2","17584","17584"
+"W249","21254.72","21655.06","21655.06","22030.28","22030.28","22104.93","22104.93","21822.79","21822.79","21445.17","21445.17","19654.69","19654.69"
+"W250","3446.7","3205.7","3207.3","3331.9","3479.1","3223.9","3228.3","3338.6","3461.4","3330.3","3232.7","3339.3","3518.5"
+"W251","6671","6836","6803","6884","6879","6940","7042","7117","7136","7116","7164","7197","7229"
+"W252","8557.6","8835.3","8859","8662.7","8563.5","8897.2","8930.5","8826.7","8675.2","8886.2","9003.2","8917.6","8732.1"
+"W253","12389","12551","12538","12445","12427","12637","12671","12626","12568","12702","12742","12726","12679"
+"W254","5953.6","5901.6","5905.5","6044.6","6050.7","5968.3","5881.8","6015.5","6050.5","6027","5981.2","6126.6","6147.7"
+"W255","1901","1898","1895","1884","1878","1866","1830","1829","1849","1870","1872","1874","1875"
+"W256","2932","2986","2914.5","3028.8","3291.8","2001.3","2192.4","2057.1","2318.1","2584.8","2583.4","2598.3","2704.1"
+"W257","4017.6","4017.9","4018.2","4018.8","4024.6","4026.8","4037","4037.9","4039.9","4041.8","4044.2","4044.3","4044.2"
+"W258","2097.4","2102.3","2087.1","2130.7","2087.5","2024.5","1983.4","1973.8","1998.2","1975.9","1931.8","1928.8","1940.1"
+"W259","6698","6436","5556","6939","6746","5285","5924","5200","6741","6343","5893","5953","5594"
+"W260","583","503","527","504","643","523","522","1437","464","626","475","785","966"
+"W261","4687.3","4661.5","4573.9","4712.8","4699.2","4555.3","4629.3","4557.9","4714","4676.1","4633.5","4639.5","4603.6"
+"W262","4382.033","4394.197","4378.668","4378.375","4378.166","4390.312","4401.788","4382.618","4382.058","4401.802","4397.108","4379.233","4378.908"
+"W263","2296","2219.6","2214.9","2044.6","2043.2","1968","1966.2","1746.1","1724.1","1701.4","1717.7","1603.2","1617"
+"W264","4071.7","4155","4247.5","4042","3908.2","3923.1","3563.7","3806.9","4360.7","4563.2","4354.9","4323.4","3629"
+"W265","2057.7","2149.37","2022.19","2061.06","2031.96","1904.36","1962.29","2017.42","2020.85","1963.84","1942.14","1973.34","2009.61"
+"W266","2072.76","2162.78","2042.96","2108.32","2022.16","1989.55","2020.05","2071.25","2013.96","1993.61","1976.23","1966.25","2030.46"
+"W267","3031.2","2833","3121.8","3662.4","3801.4","3635.9","3732.4","2989.6","4445.3","4025.2","4599.9","4366.5","3613.2"
+"W268","1306.27","1382.07","1271.27","1314.49","1308.47","1194.08","1259.07","1298.64","1304.74","1285.92","1251.62","1308.33","1369.04"
+"W269","1258.78","1335.44","1229.92","1305.02","1251.08","1192.61","1232.56","1280.13","1217.91","1237.3","1200.59","1223","1325.46"
+"W270","7727.9","8061.2","7905.6","7710.1","7937.5","7954.8","8244.7","8336.4","8431.2","8311.7","8421.9","8301.7","8375.9"
+"W271","7661.3","7754.9","7634.3","7495.5","7846.8","7899.6","8028.8","8126.1","8295.7","8169","8102.7","7990.4","8058.8"
+"W272","974.11","971.93","949.5","952.55","956.53","955.04","928.78","934.69","937.57","942.2","943.45","949.25","951.63"
+"W273","6542.2","6602.2","6631.8","6704.4","6867.5","6809.7","6853.3","6828.4","6750.5","6774.3","6767.8","6564.6","6614.5"
+"W274","751.43","767.3","750.92","746.57","723.49","710.28","703.22","718.78","716.11","677.92","690.52","665.01","640.57"
+"W275","8139.8","8273.4","8130.4","8033","7710.8","7969.4","7874.9","7911.2","7960.5","7563.1","7756.4","7432.5","7050"
+"W276","11409.5","11408.2","11485.6","11820.4","11735","12147","11899.3","11303.7","11336.7","11585.8","11662.6","11191.2","10895.7"
+"W277","3257.323","3271.85","3284.499","3248.314","3162.48","3345.109","3283.453","3260.614","3232.998","3257.269","3299.522","3306.657","3294.326"
+"W278","1261.984","1332.9","1226.2","1267.01","1266.63","1153.61","1217.88","1256.22","1260.13","1249.54","1214.15","1271.59","1333.46"
+"W279","1212.443","1284.81","1181.98","1256.58","1204.17","1146.31","1184.67","1231.88","1164.92","1195.17","1157.35","1182.41","1284.83"
+"W280","5447.979","5462.14","5487.29","5483.53","5478.69","5471.28","5473.97","5487.77","5448.53","5428.96","5440.01","5462.1","5471.9"
+"W281","1756","1849","1859","1774","1799","1895","1793","1730","1815","1919","1963","1977","2010"
+"W282","2144.366551","2155.275445","2134.710461","2155.964119","2136.584281","2111.357748","2151.224229","2102.505934","2097.694159","2081.464003","2116.373998","2109.410461","2135.181639"
+"W283","338.554154","335.62152","339.293614","334.767926","346.838264","348.526527","321.768721","345.408096","330.985181","329.278867","317.836472","335.474349","303.970852"
+"W284","572.83","578.84","601.86","577.06","575.18","583.88","583.42","586.89","590.86","592.64","588.47","514.43","504.2"
+"W285","692.124","687.527","691.085","705.06","706.426","697.053","691.771","695.644","716.192","722.715","721.569","721.882","739.725"
+"W286","10549","10683.7","10413.7","10294.3","10494.1","10588","10359.7","10236.7","10403.6","10394.8","10697.7","10778.3","10831.8"
+"W287","2187.16","2205.63","2214.48","2228.7","2312.59","2368.47","2384.82","2353.87","2374.86","2351.83","2331.47","2340.08","2351.46"
+"W288","7742.4","7742.4","7747.4","7750.3","7712.9","7875.2","7871.1","7867.6","7867.8","7865.8","7865.3","7841.8","7779.9"
+"W289","9790","9800","10160","9960","9920","9710","10070","9970","10000","9770","9840","9840","9750"
+"W290","15593.6","15096.7","13956.7","14349.8","14700.6","15026.8","14956.2","15354.3","15842.4","16424.9","16261.7","16238.3","16523.1"
+"W291","7931","7981.7","7898.8","8095.8","7630.4","8375.1","8041","8141.3","7431.5","7448.9","7899","7716.7","7367"
+"W292","17618.9","17397.7","17308.2","17341.1","16890.5","17910.6","17573.8","17610.4","16916.2","16970.8","17256","16901","15827.8"
+"W293","1873","1748","3351","2824","2482","1905","1900","1817","1985","1709","1949","1641","1941"
+"W294","1255.8","1480.5","1196.1","1618.8","1318.5","1427.8","1197.9","1301.9","996","1153.8","1343.5","1270.2","1210.1"
+"W295","3090","3218","3071","3054","3124","3185","3205","3158","3235","3157","3002","3736","3258"
+"W296","3427","2655","2957","3214","2609","1843","2775","3629","3045","2894","2500","3242","3062"
+"W297","5520","4651","4787","5396","4341","3130","4231","4702","5425","4859","4622","5740","5070"
+"W298","3806","2828","3516","3576","2979","1842","3514","4137","3570","3348","3245","4174","3695"
+"W299","3952","3296","3338","3522","3138","2128","2955","3950","3260","3003","2981","3182","3275"
+"W300","2374","1834","1881","1979","1699","1155","1765","2300","1820","1777","1643","1919","1892"
+"W301","3392","2854","2689","2867","2815","2185","2861","2947","2624","2433","2365","2874","2649"
+"W302","3121","2733","2775","3159","2695","2770","3158","2702","3445","3021","3534","4221","3385"
+"W303","5797","4859","5145","5401","4446","3132","4343","5185","5489","5312","5005","6408","5480"
+"W304","3253","2595","2754","2963","2634","1609","2817","3632","3136","2790","2432","3129","3024"
+"W305","3358","2770","2791","2943","2574","1892","2428","3243","2828","2730","2560","3425","2957"
+"W306","2558","2048","2187","2435","1885","1225","2385","3028","2388","2236","2135","2696","2497"
+"W307","3460","3044","3400","3706","2874","2274","2800","3050","3473","2985","3099","3948","3311"
+"W308","2573","2124","2185","2420","1932","1351","1891","2117","2349","2289","2047","2592","2279"
+"W309","7378","6631","6561","7425","7372","6258","8446","7995","6836","6070","5230","6259","6478"
+"W310","5183","4647","5227","5734","5549","4025","5253","6645","5251","4651","4383","5649","5316"
+"W311","5535","4926","4816","5557","5197","3914","4856","5834","5014","4424","3970","4932","4835"
+"W312","4895","4096","4309","4967","5689","3706","4645","4642","4373","3965","3795","4215","4198"
+"W313","2115","2203","2102","2090","2138","2180","2194","2162","2214","2161","2055","2557","2230"
+"W314","9441","8986","8449","9450","9509","7357","8471","9510","8440","8063","7471","8021","8301"
+"W315","5316","5008","5037","5095","5226","3920","4911","5467","4717","4589","4346","4605","4745"
+"W316","3210","2787","2867","3217","3157","2388","2739","3447","3038","2883","2938","3259","3113"
+"W317","4508","3991","3886","4226","4297","3077","3922","4642","4072","3787","3349","4066","3983"
+"W318","3655","3808","3633","3613","3695","3768","3792","3736","3827","3735","3552","4420","3854"
+"W319","2547","2678","2381","2733","2894","1965","2326","3097","2363","2247","2099","2524","2466"
+"W320","2572","2584","2776","3036","3647","2357","2695","3086","2379","1989","1862","2062","2276"
+"W321","6172","5932","5665","6110","5342","4145","5273","5132","6994","6018","5745","6651","6108"
+"W322","2626","2370","2401","2830","3284","2103","2352","2865","2483","2381","2317","2530","2515"
+"W323","5324","4761","4912","5730","6273","4394","5408","6709","5429","5251","4661","5976","5605"
+"W324","3057","2539","2419","2741","2917","2209","2798","3546","3183","3140","2856","3481","3241"
+"W325","3215","3336","3183","3166","3238","3301","3322","3274","3354","3273","3112","3872","3377"
+"W326","3852","3618","3667","4098","3958","2932","3769","4767","4198","3692","3344","4281","2884"
+"W327","9791","8592","8763","9250","7963","6586","9213","11666","10414","9639","9268","11945","10586"
+"W328","2826","2377","2613","2854","2688","1744","2439","3290","2774","2447","2203","2916","2726"
+"W329","11786","9960","9820","10747","10786","7966","9968","12266","10587","8995","8982","11725","10511"
+"W330","3899","3130","3356","3606","3534","2475","3407","4577","4188","3678","3283","4192","3984"
+"W331","6871","5873","6170","6691","6293","4403","6148","7417","6375","5700","5761","6663","7417"
+"W332","3191","3095","2805","3275","3230","2471","3448","4534","3545","3233","3179","3157","3530"
+"W333","2774","2724","2885","3325","3629","2345","3088","3348","2915","2738","2573","3229","2961"
+"W334","4019","3939","4008","4178","4154","3076","3917","4989","4219","4007","3832","4543","4318"
+"W335","5003","4375","4539","4653","5501","3930","4734","5515","5429","4309","3932","4650","4767"
+"W336","1984","1637","2053","2085","2375","1537","2031","2317","1744","1468","1250","1730","1702"
+"W337","1682","2188","1939","2411","2429","1734","1835","2171","1857","1650","1562","2022","1350"
+"W338","2838","2690","2470","3041","3116","2190","2571","3022","2481","2196","2106","2391","2614"
+"W339","4385","3907","3606","3890","3564","2431","3703","4398","3699","3437","3386","4085","3801"
+"W340","7431","6881","7184","7855","7520","6190","7526","7912","7010","6089","6089","6444","6709"
+"W341","5896","5259","5643","6241","6242","4539","5038","6269","5306","4688","4423","5340","5205"
+"W342","1717.1","1304.4","1335.5","1379.2","1276.9","1007.2","1323","1575.6","1307","1264.5","1118.6","1349.1","1323"
+"W343","4274","3596","3596","4510","4182","2859","3579","4723","4013","3409","3143","4375","3933"
+"W344","3730","3182","3165","3463","3098","1955","2964","4003","3550","3348","3014","3879","3559"
+"W345","3807","3360","3266","3406","3122","2212","2982","3988","3389","3160","3126","3584","3988"
+"W346","7012","5532","5818","5845","5240","3442","5592","6704","5512","5418","5004","5866","5701"
+"W347","4217","3343","3621","3938","3702","2575","3277","4485","3790","3487","3158","4196","3823"
+"W348","4952","4054","3637","4411","4431","2762","3708","4300","5288","4673","3860","5166","4657"
+"W349","3449","3593","3428","3409","3487","3556","3578","3526","3612","3525","3352","4171","3637"
+"W350","6407","5330","5444","5744","4513","3424","6361","6498","5367","5326","5042","6151","5677"
+"W351","2083","1704","1622","1626","1306","1010","1719","2189","1661","1753","1591","2057","1850"
+"W352","1339","1395","1331","1324","1354","1381","1389","1369","1402","1369","1302","1619","1412"
+"W353","2197","1711","1661","1535","1444","953","1526","1840","1722","1540","1534","1671","1661"
+"W354","3513","3203","2907","3031","2335","1945","3178","4175","3651","3512","3573","4511","3884"
+"W355","2777","2893","2760","2745","2807","2862","2880","2838","2908","2838","2698","3357","2928"
+"W356","4387","3772","3660","3878","3131","2405","4081","4811","4170","4017","3824","4661","4297"
+"W357","3938","3363","3249","3515","3097","2275","3421","4166","3807","3434","3303","4024","3747"
+"W358","6907","5711","5496","5862","5380","3660","5159","6787","5596","5445","5345","6156","5866"
+"W359","4458","5098","4518","4973","3973","2613","3476","4213","3386","3627","3299","3743","3965"

dataset/m4/Yearly-train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6aa668d4f04654c0bf5f07b266a51c556f0df2faf4709f852653755396a249e4
+size 25355736

dataset/m4/submission-Naive2.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9610c625d6dee654ec458dcd07fb39373d065efc33b4f17d94c50b2aef00ef9
+size 23409576

dataset/m4/test.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:134249cd801d51507af9de3c77b4c789da4de96cb5a2d2fe2988cac138820d32
+size 20778257

dataset/m4/training.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1799e5334656df0e7ff68ea016f555aa23e5460890e5f92a59f907deba5a7914
+size 270896295

dataset/poly/polymarket_data_processed_Crypto_test.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8197ef536a3f9ef9399dc3205d39ca5cd3ac3c38bb5df2033ef74198402f2b91
+size 34744628

dataset/poly/polymarket_data_processed_Election_test.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2ccfdbf65e9fc4f173daa3cfdc1ddf771a064319beb82c723c014b30ff0a1a3
+size 30018418

dataset/poly/polymarket_data_processed_Other_test.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:200fb59b5a8d640d9e27e5fe88a2e323f157ab905e67f5209f95b38234873fe7
+size 70988203

dataset/poly/polymarket_data_processed_Politics_test.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7468321988e461dfdb449526db0c67274e77180c78d9d999cb7a075c683fc01
+size 186831387

dataset/poly/polymarket_data_processed_Sports_test.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4574cd57806a46ba5b8576a0ed5467fa81c6ed82a86188d255ef3ddd6bbf9dc5
+size 27514781

dataset/poly/polymarket_data_processed_dev.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:260d436493fe1b4b69b1d5f35808c1ce90088cf5a51bc7a6433b96039baef23f
+size 456387925

dataset/poly/polymarket_data_processed_test.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fca43646308d0b5c098f5ac529b9b1bb5703f334c26c327e2c3696de32602625
+size 420577190

dataset/poly/polymarket_data_processed_train.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a08508154ae529fad7a4cbb174ad47d6702e99bae04cf18b7310c52c6ff3f4c4
+size 2609542664

exp/exp_anomaly_detection.py

@@ -0,0 +1,207 @@
+from 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

exp/exp_basic.py

@@ -0,0 +1,79 @@
+import os
+import torch
+from models import Autoformer, Transformer, TimesNet, Nonstationary_Transformer, DLinear, FEDformer, \
+    Informer, LightTS, Reformer, ETSformer, Pyraformer, PatchTST, MICN, Crossformer, FiLM, iTransformer, \
+    Koopa, TiDE, FreTS, TimeMixer, TSMixer, SegRNN, MambaSimple, TemporalFusionTransformer, SCINet, PAttn, TimeXer, \
+    WPMixer, MultiPatchFormer
+
+
+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,
+            'iTransformer': iTransformer,
+            'Koopa': Koopa,
+            'TiDE': TiDE,
+            'FreTS': FreTS,
+            'MambaSimple': MambaSimple,
+            'TimeMixer': TimeMixer,
+            'TSMixer': TSMixer,
+            'SegRNN': SegRNN,
+            'TemporalFusionTransformer': TemporalFusionTransformer,
+            "SCINet": SCINet,
+            'PAttn': PAttn,
+            'TimeXer': TimeXer,
+            'WPMixer': WPMixer,
+            'MultiPatchFormer': MultiPatchFormer
+        }
+        if args.model == 'Mamba':
+            print('Please make sure you have successfully installed mamba_ssm')
+            from models import Mamba
+            self.model_dict['Mamba'] = Mamba
+
+        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 and self.args.gpu_type == 'cuda':
+            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))
+        elif self.args.use_gpu and self.args.gpu_type == 'mps':
+            device = torch.device('mps')
+            print('Use GPU: mps')
+        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

exp/exp_classification.py

@@ -0,0 +1,191 @@
+from 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)
+        model_optim = optim.RAdam(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
+
+        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))
+        file_name='result_classification.txt'
+        f = open(os.path.join(folder_path,file_name), 'a')
+        f.write(setting + "  \n")
+        f.write('accuracy:{}'.format(accuracy))
+        f.write('\n')
+        f.write('\n')
+        f.close()
+        return

exp/exp_imputation.py

@@ -0,0 +1,228 @@
+from 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:]
+
+                # add support for MS
+                batch_x = batch_x[:, :, f_dim:]
+                mask = mask[:, :, 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:]
+
+                # add support for MS
+                batch_x = batch_x[:, :, f_dim:]
+                mask = mask[:, :, 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:]
+
+                # add support for MS 
+                batch_x = batch_x[:, :, f_dim:]
+                mask = mask[:, :, 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

exp/exp_long_term_forecasting.py

@@ -0,0 +1,268 @@
+from 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
+from utils.dtw_metric import dtw, accelerated_dtw
+from utils.augmentation import run_augmentation, run_augmentation_single
+
+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():
+                        outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)
+                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():
+                        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:
+                    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():
+                        outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)
+                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:, :]
+                batch_y = batch_y[:, -self.args.pred_len:, :].to(self.device)
+                outputs = outputs.detach().cpu().numpy()
+                batch_y = batch_y.detach().cpu().numpy()
+                if test_data.scale and self.args.inverse:
+                    shape = batch_y.shape
+                    if outputs.shape[-1] != batch_y.shape[-1]:
+                        outputs = np.tile(outputs, [1, 1, int(batch_y.shape[-1] / outputs.shape[-1])])
+                    outputs = test_data.inverse_transform(outputs.reshape(shape[0] * shape[1], -1)).reshape(shape)
+                    batch_y = test_data.inverse_transform(batch_y.reshape(shape[0] * shape[1], -1)).reshape(shape)
+
+                outputs = outputs[:, :, f_dim:]
+                batch_y = batch_y[:, :, f_dim:]
+
+                pred = outputs
+                true = batch_y
+
+                preds.append(pred)
+                trues.append(true)
+                if i % 20 == 0:
+                    input = batch_x.detach().cpu().numpy()
+                    if test_data.scale and self.args.inverse:
+                        shape = input.shape
+                        input = test_data.inverse_transform(input.reshape(shape[0] * shape[1], -1)).reshape(shape)
+                    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.concatenate(preds, axis=0)
+        trues = np.concatenate(trues, axis=0)
+        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)
+
+        # dtw calculation
+        if self.args.use_dtw:
+            dtw_list = []
+            manhattan_distance = lambda x, y: np.abs(x - y)
+            for i in range(preds.shape[0]):
+                x = preds[i].reshape(-1, 1)
+                y = trues[i].reshape(-1, 1)
+                if i % 100 == 0:
+                    print("calculating dtw iter:", i)
+                d, _, _, _ = accelerated_dtw(x, y, dist=manhattan_distance)
+                dtw_list.append(d)
+            dtw = np.array(dtw_list).mean()
+        else:
+            dtw = 'Not calculated'
+
+        mae, mse, rmse, mape, mspe = metric(preds, trues)
+        print('mse:{}, mae:{}, dtw:{}'.format(mse, mae, dtw))
+        f = open("result_long_term_forecast.txt", 'a')
+        f.write(setting + "  \n")
+        f.write('mse:{}, mae:{}, dtw:{}'.format(mse, mae, dtw))
+        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

exp/exp_short_term_forecasting.py

@@ -0,0 +1,302 @@
+from 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 as pd
+
+warnings.filterwarnings('ignore')
+
+
+def mse(output, label):
+    mse_value = (output - label) ** 2
+    return np.mean(mse_value)
+
+
+def rmse(output, label):
+    mse_value = mse(output=output, label=label)
+    return np.sqrt(mse_value)
+
+
+def mae(output, label):
+    mae_value = np.abs(output - label)
+    return np.mean(mae_value)
+
+
+def mape(output, label):
+    # 避免除以零
+    mask = label != 0
+    mape_value = np.abs((output[mask] - label[mask]) / label[mask])
+    return np.mean(mape_value) * 100
+
+
+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]
+            self.args.seq_len = 2 * self.args.pred_len
+            self.args.label_len = self.args.pred_len
+            self.args.frequency_map = M4Meta.frequency_map[self.args.seasonal_patterns]
+        elif self.args.data == 'kalshi':
+            # Poly 数据集使用命令行传入的参数，不需要特殊处理
+            self.args.frequency_map = 1
+        elif self.args.data == 'poly':
+            # Poly 数据集使用命令行传入的参数，不需要特殊处理
+            self.args.frequency_map = 1
+        
+        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 _prepare_data_from_timeseries(self, timeseries):
+        """
+        从 timeseries 中提取 x 和 y
+        timeseries 中每个元素长度 >= seq_len + 1
+        x: 最后 seq_len 个点（不含 after）
+        y: 最后 pred_len 个点（after）
+        """
+        x_list = []
+        y_list = []
+        
+        for ts in timeseries:
+            # 取最后 seq_len+1 个点
+            # x = ts[-(seq_len+1):-1], y = ts[-pred_len:]
+            x_list.append(ts[-(self.args.seq_len + 1):-1])
+            y_list.append(ts[-self.args.pred_len:])
+        
+        x = torch.tensor(x_list, dtype=torch.float32).to(self.device)
+        x = x.unsqueeze(-1)  # (B, seq_len, 1)
+        y = np.array(y_list)  # (B, pred_len)
+        
+        return x, y
+
+    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_loss = 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)  # (B, seq_len, 1)
+                batch_y = batch_y.float().to(self.device)  # (B, label_len + pred_len, 1)
+                batch_y_mark = batch_y_mark.float().to(self.device)
+
+                # decoder input: [label_len 个真实值, pred_len 个零]
+                dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float().to(self.device)
+                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)
+
+                # 使用简单的 MSE loss
+                if self.args.loss == 'MSE':
+                    loss = mse_loss(outputs, batch_y)
+                else:
+                    batch_y_mark = batch_y_mark[:, -self.args.pred_len:, f_dim:].to(self.device)
+                    loss = criterion(batch_x, self.args.frequency_map, outputs, batch_y, batch_y_mark)
+                
+                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_loader)
+            print("Epoch: {0}, Steps: {1} | Train Loss: {2:.7f} Vali Loss: {3:.7f}".format(
+                epoch + 1, train_steps, train_loss, vali_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, vali_loader):
+        """验证函数"""
+        timeseries = vali_loader.dataset.timeseries
+        x, y = self._prepare_data_from_timeseries(timeseries)
+
+        self.model.eval()
+        with torch.no_grad():
+            B, _, C = x.shape
+            
+            # decoder input
+            dec_inp = torch.zeros((B, self.args.pred_len, C)).float().to(self.device)
+            # 从 x 中取最后 label_len 个点作为 decoder 的已知输入
+            dec_inp = torch.cat([x[:, -self.args.label_len:, :], dec_inp], dim=1).float()
+            
+            # 分批推理，避免 OOM
+            outputs = torch.zeros((B, self.args.pred_len, C)).float()
+            batch_size = 500
+            id_list = np.arange(0, B, batch_size)
+            id_list = np.append(id_list, B)
+            
+            for i in range(len(id_list) - 1):
+                start_idx, end_idx = id_list[i], id_list[i + 1]
+                outputs[start_idx:end_idx, :, :] = self.model(
+                    x[start_idx:end_idx], None,
+                    dec_inp[start_idx:end_idx], None
+                ).detach().cpu()
+
+            f_dim = -1 if self.args.features == 'MS' else 0
+            outputs = outputs[:, -self.args.pred_len:, f_dim:]
+            
+            pred = outputs.numpy()
+            true = y
+            
+            loss = mse(pred, true)
+
+        self.model.train()
+        return loss
+    def test(self, setting, test=0):
+        """测试函数"""
+        # 测试多个数据集
+        flags = ['test', 'test_Companies', 'test_Economics', 'test_Entertainment', 'test_Mentions', 'test_Politics']
+        # flags = ['test', 'test_Crypto', 'test_Politics', 'test_Election']
+        
+        results = []
+        columns = []
+        
+        for flag in flags:
+            try:
+                _, test_loader = self._get_data(flag=flag)
+            except Exception as e:
+                print(f"Skipping {flag}: {e}")
+                continue
+                
+            timeseries = test_loader.dataset.timeseries
+            
+            if len(timeseries) == 0:
+                print(f"[{flag}] No samples, skipping...")
+                continue
+                
+            x, y = self._prepare_data_from_timeseries(timeseries)
+
+            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
+                
+                # decoder input
+                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()
+                
+                # 分批推理
+                outputs = torch.zeros((B, self.args.pred_len, C)).float().to(self.device)
+                batch_size = 500
+                id_list = np.arange(0, B, batch_size)
+                id_list = np.append(id_list, B)
+                
+                for i in range(len(id_list) - 1):
+                    start_idx, end_idx = id_list[i], id_list[i + 1]
+                    outputs[start_idx:end_idx, :, :] = self.model(
+                        x[start_idx:end_idx], None,
+                        dec_inp[start_idx:end_idx], None
+                    )
+                    if start_idx % 1000 == 0:
+                        print(f"Processed {start_idx}/{B}")
+
+                f_dim = -1 if self.args.features == 'MS' else 0
+                outputs = outputs[:, -self.args.pred_len:, f_dim:]
+                preds = outputs.detach().cpu().numpy()
+                trues = y
+
+            print(f'[{flag}] Test shape: {preds.shape}')
+
+            # 计算指标
+            rmse_val = rmse(preds, trues)
+            mae_val = mae(preds, trues)
+            
+            columns.extend([f'{flag}_rmse', f'{flag}_mae'])
+            results.extend([rmse_val, mae_val])
+            
+            print(f'[{flag}] RMSE: {rmse_val:.6f}, MAE: {mae_val:.6f}')
+
+        # 保存结果
+        folder_path = f'./{self.args.data}_results/' + self.args.model + '/'
+        if not os.path.exists(folder_path):
+            os.makedirs(folder_path)
+            
+        df = pd.DataFrame([results], columns=columns)
+        result_path = os.path.join(folder_path, f'{self.args.model}_results.csv')
+        df.to_csv(result_path, index=False)
+        print(f'Results saved to {result_path}')
+        
+        return results

kalshi_results/Autoformer/Autoformer_results.csv

@@ -0,0 +1,2 @@
+test_rmse,test_mae,test_Companies_rmse,test_Companies_mae,test_Economics_rmse,test_Economics_mae,test_Entertainment_rmse,test_Entertainment_mae,test_Mentions_rmse,test_Mentions_mae,test_Politics_rmse,test_Politics_mae
+0.40856921686443876,0.3217217668927483,0.364304113186295,0.28937346579139905,0.5096567834520302,0.3970817213714233,0.40597254578512976,0.3254350355656028,0.3871389816162235,0.32037402264013803,0.40295968229454693,0.3157070307474669

kalshi_results/DLinear/DLinear_results.csv

@@ -0,0 +1,2 @@
+test_rmse,test_mae,test_Companies_rmse,test_Companies_mae,test_Economics_rmse,test_Economics_mae,test_Entertainment_rmse,test_Entertainment_mae,test_Mentions_rmse,test_Mentions_mae,test_Politics_rmse,test_Politics_mae
+0.3891896238849517,0.30230516746317077,0.351860807826818,0.27699875265589174,0.48147644981667514,0.37157798860447333,0.3897480740571339,0.30954725156348983,0.3710907844730615,0.3075220013497144,0.3831593945812524,0.29365767848840196

layers/AutoCorrelation.py

@@ -0,0 +1,163 @@
+import 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).to(values.device)
+        # 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).to(values.device)
+        # 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

layers/Autoformer_EncDec.py

@@ -0,0 +1,203 @@
+import 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