Add files using upload-large-folder tool

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_10478.csv

@@ -0,0 +1,9 @@
+0.7254
+0.7488
+0.8034
+0.8658
+0.9048
+0.9204
+0.936
+0.9204
+0.9126

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_1067.csv

@@ -0,0 +1,10 @@
+-0.1638
+-0.1092
+0.0156
+0.1248
+0.1872
+0.2262
+0.2496
+0.2964
+0.3198
+0.3354

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_11159.csv

@@ -0,0 +1,31 @@
+-0.3276
+-0.2652
+-0.2496
+-0.234
+-0.234
+-0.273
+-0.3198
+-0.3744
+-0.4446
+-0.507
+-0.5382
+-0.6084
+-0.6162
+-0.624
+-0.6552
+-0.702
+-0.7956
+-0.8502
+-0.8502
+-0.8268
+-0.8424
+-0.9282
+-1.0062
+-1.0374
+-1.053
+-1.0608
+-1.0218
+-0.9126
+-0.7956
+-0.702
+-0.546

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_11169.csv

@@ -0,0 +1,15 @@
+149.0
+140.0
+129.5
+117.0
+104.0
+88.5
+75.5
+62.0
+49.0
+36.5
+24.5
+14.0
+6.5
+-2.0
+-9.5

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_11194.csv

@@ -0,0 +1,26 @@
+3.0
+3.0
+1.0
+-1.0
+-1.5
+-3.5
+-6.5
+-5.5
+-7.5
+-8.0
+-9.0
+-10.5
+-11.5
+-13.5
+-15.5
+-17.0
+-19.5
+-21.5
+-23.0
+-24.0
+-27.0
+-29.0
+-29.5
+-31.0
+-33.0
+-34.0

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_1121.csv

@@ -0,0 +1,21 @@
+32.38
+28.97
+24.5
+19.34
+14.75
+10.97
+9.28
+8.88
+10.5
+13.91
+16.5
+20.44
+23.91
+25.81
+26.0
+26.5
+24.91
+22.97
+21.94
+20.03
+18.44

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_11297.csv

@@ -0,0 +1,30 @@
+35.47
+34.38
+33.78
+31.88
+31.34
+30.19
+30.88
+29.56
+30.53
+31.19
+31.44
+31.75
+31.88
+33.56
+34.5
+36.25
+39.0
+40.31
+40.75
+41.16
+41.03
+40.34
+40.34
+41.31
+42.5
+43.62
+43.84
+43.66
+42.66
+41.59

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_11391.csv

@@ -0,0 +1,32 @@
+0.4223
+0.4203
+0.4193
+0.4193
+0.4184
+0.4184
+0.4184
+0.4184
+0.4184
+0.4184
+0.4174
+0.4164
+0.4164
+0.4154
+0.4154
+0.4164
+0.4174
+0.4174
+0.4184
+0.4184
+0.4184
+0.4184
+0.4184
+0.4174
+0.4164
+0.4164
+0.4164
+0.4184
+0.4233
+0.4301
+0.4409
+0.4555

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_11829.csv

@@ -0,0 +1,10 @@
+26.22
+26.81
+28.56
+27.84
+27.53
+27.16
+25.31
+25.88
+25.31
+26.31

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_11993.csv

@@ -0,0 +1,31 @@
+-35.5
+-34.0
+-31.0
+-27.5
+-25.5
+-20.0
+-14.0
+-9.0
+-3.5
+-0.5
+8.5
+15.5
+20.0
+27.5
+33.5
+42.0
+49.0
+56.0
+62.5
+67.5
+75.0
+82.0
+86.0
+88.0
+89.5
+94.5
+94.5
+92.5
+88.5
+85.0
+82.5

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_1216.csv

@@ -0,0 +1,32 @@
+0.3978
+0.39
+0.3822
+0.351
+0.3276
+0.2964
+0.2652
+0.2496
+0.234
+0.2262
+0.2184
+0.2184
+0.2262
+0.2418
+0.2808
+0.3276
+0.3822
+0.4758
+0.5772
+0.7332
+0.9048
+1.0998
+1.3026
+1.482
+1.6068
+1.677
+1.7238
+1.755
+1.7238
+1.6302
+1.5288
+1.4196

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_12478.csv

@@ -0,0 +1,27 @@
+-24.72
+-23.09
+-21.88
+-21.78
+-21.97
+-23.22
+-23.53
+-23.84
+-24.25
+-25.41
+-25.97
+-27.44
+-29.59
+-31.16
+-31.47
+-33.28
+-32.47
+-30.53
+-29.47
+-27.34
+-24.66
+-23.28
+-21.25
+-20.31
+-18.66
+-16.78
+-17.56

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_12539.csv

@@ -0,0 +1,26 @@
+0.6608
+0.6745
+0.6862
+0.694
+0.7009
+0.7048
+0.7067
+0.7067
+0.7067
+0.7048
+0.7019
+0.697
+0.6891
+0.6794
+0.6667
+0.652
+0.6285
+0.6012
+0.5806
+0.564
+0.5464
+0.5308
+0.5152
+0.5024
+0.4897
+0.48

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_12565.csv

@@ -0,0 +1,26 @@
+0.5
+1.0
+2.0
+3.5
+4.0
+5.0
+5.5
+7.0
+7.0
+8.5
+11.5
+11.5
+15.5
+19.5
+22.0
+25.0
+30.0
+35.5
+39.5
+43.0
+45.5
+47.0
+50.0
+50.0
+49.0
+48.5

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_13670.csv

@@ -0,0 +1,14 @@
+0.4457
+0.434
+0.4233
+0.4135
+0.4057
+0.3969
+0.3871
+0.3773
+0.3685
+0.3587
+0.349
+0.3392
+0.3294
+0.3196

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_13799.csv

@@ -0,0 +1,9 @@
+0.3978
+0.4524
+0.4524
+0.4602
+0.4524
+0.4524
+0.4602
+0.4602
+0.468

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_13903.csv

@@ -0,0 +1,14 @@
+36.0
+22.5
+10.5
+-4.5
+-13.5
+-24.0
+-33.5
+-43.0
+-50.0
+-55.0
+-61.0
+-64.0
+-67.5
+-71.0

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_14303.csv

@@ -0,0 +1,23 @@
+0.1716
+0.1872
+0.2262
+0.2418
+0.2574
+0.2808
+0.312
+0.2886
+0.2418
+0.1716
+0.0702
+-0.039
+-0.1248
+-0.1326
+-0.1014
+-0.078
+-0.1014
+-0.1872
+-0.273
+-0.3276
+-0.3432
+-0.3432
+-0.3198

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_14349.csv

@@ -0,0 +1,19 @@
+17.91
+20.28
+24.81
+27.5
+31.5
+36.44
+40.31
+43.56
+44.28
+45.06
+44.19
+41.03
+38.0
+34.78
+32.06
+30.34
+28.75
+28.75
+29.97

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_15152.csv

@@ -0,0 +1,25 @@
+0.819
+0.7722
+0.7332
+0.7098
+0.6786
+0.6474
+0.624
+0.6084
+0.6006
+0.6084
+0.6162
+0.624
+0.663
+0.6864
+0.6942
+0.7176
+0.741
+0.78
+0.8112
+0.8424
+0.8736
+0.9204
+0.9516
+0.9906
+1.0296

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_15750.csv

@@ -0,0 +1,29 @@
+0.4751
+0.4741
+0.4731
+0.4731
+0.4721
+0.4702
+0.4672
+0.4643
+0.4614
+0.4585
+0.4545
+0.4516
+0.4477
+0.4438
+0.4389
+0.434
+0.4291
+0.4252
+0.4233
+0.4213
+0.4184
+0.4174
+0.4164
+0.4145
+0.4145
+0.4145
+0.4135
+0.4125
+0.4115

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_16254.csv

@@ -0,0 +1,19 @@
+17.94
+19.03
+19.94
+20.22
+19.44
+18.5
+17.25
+16.09
+15.03
+14.72
+14.84
+15.19
+15.56
+15.81
+17.0
+16.81
+17.78
+18.12
+19.12

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_16900.csv

@@ -0,0 +1,8 @@
+-318.0
+-303.5
+-284.5
+-264.5
+-239.5
+-212.5
+-184.5
+-153.5

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_17049.csv

@@ -0,0 +1,17 @@
+20.19
+23.53
+27.97
+30.62
+31.25
+30.66
+27.16
+22.75
+18.5
+16.81
+16.28
+16.12
+17.25
+18.66
+17.66
+16.69
+14.66

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_17143.csv

@@ -0,0 +1,12 @@
+16.16
+16.91
+16.62
+16.41
+16.31
+16.41
+14.53
+15.94
+16.03
+16.06
+17.0
+17.5

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_18073.csv

@@ -0,0 +1,18 @@
+35.28
+34.25
+32.81
+32.5
+30.78
+29.81
+26.5
+24.72
+22.66
+21.69
+21.03
+21.41
+22.28
+22.34
+20.81
+19.78
+16.62
+13.97

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_18087.csv

@@ -0,0 +1,28 @@
+0.69
+0.47
+1.31
+1.41
+3.44
+5.28
+7.19
+9.25
+10.31
+11.12
+12.0
+13.16
+13.5
+14.12
+15.72
+16.25
+15.59
+16.06
+15.69
+14.25
+14.25
+13.31
+13.31
+13.59
+13.12
+13.03
+13.03
+13.97

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_2451.csv

@@ -0,0 +1,14 @@
+-0.5538
+-0.5616
+-0.5694
+-0.585
+-0.585
+-0.5772
+-0.5694
+-0.5226
+-0.4602
+-0.39
+-0.3354
+-0.2886
+-0.2652
+-0.2028

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_3518.csv

@@ -0,0 +1,9 @@
+36.5
+28.0
+17.5
+8.0
+-3.5
+-12.5
+-21.0
+-27.5
+-33.5

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_4951.csv

@@ -0,0 +1,13 @@
+8.88
+9.69
+8.44
+8.56
+7.31
+7.16
+5.44
+3.81
+4.19
+4.56
+4.12
+5.59
+8.06

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_5170.csv

@@ -0,0 +1,32 @@
+0.1872
+0.1716
+0.156
+0.1404
+0.1404
+0.1248
+0.1404
+0.156
+0.1638
+0.1638
+0.1638
+0.1638
+0.1716
+0.1638
+0.1716
+0.2262
+0.2886
+0.3588
+0.3588
+0.3432
+0.2964
+0.2652
+0.2496
+0.2418
+0.2418
+0.273
+0.2964
+0.3276
+0.3354
+0.3822
+0.3978
+0.4212

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_5206.csv

@@ -0,0 +1,11 @@
+22.56
+23.84
+22.91
+21.88
+19.75
+18.91
+17.25
+16.22
+17.06
+17.56
+18.59

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_5699.csv

@@ -0,0 +1,17 @@
+0.6207
+0.6031
+0.5836
+0.563
+0.5415
+0.52
+0.4995
+0.48
+0.4604
+0.4428
+0.4262
+0.4115
+0.3998
+0.3891
+0.3803
+0.3734
+0.3675

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_6034.csv

@@ -0,0 +1,14 @@
+-14.0
+-12.5
+-12.0
+-12.0
+-10.5
+-6.0
+-3.0
+-1.0
+3.0
+7.5
+12.0
+17.0
+21.0
+24.5

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_6218.csv

@@ -0,0 +1,26 @@
+1.2714
+1.1934
+1.0842
+0.9594
+0.8424
+0.741
+0.6318
+0.5226
+0.4134
+0.3276
+0.2496
+0.1716
+0.117
+0.0312
+-0.0234
+-0.1014
+-0.1482
+-0.1872
+-0.2184
+-0.2496
+-0.273
+-0.2964
+-0.3276
+-0.3588
+-0.351
+-0.3588

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_6497.csv

@@ -0,0 +1,27 @@
+34.59
+35.06
+36.28
+35.66
+35.06
+33.69
+32.56
+31.44
+29.69
+30.56
+30.88
+31.72
+33.06
+34.16
+36.41
+37.69
+39.19
+41.59
+42.59
+44.03
+45.41
+44.22
+42.66
+40.62
+36.81
+33.47
+31.25

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_6766.csv

@@ -0,0 +1,9 @@
+0.8658
+0.858
+0.8112
+0.78
+0.7566
+0.7254
+0.702
+0.6786
+0.6786

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_7972.csv

@@ -0,0 +1,24 @@
+-0.0234
+-0.039
+-0.039
+-0.0312
+-0.0468
+-0.039
+-0.0468
+-0.0468
+-0.0468
+-0.0546
+-0.0468
+-0.039
+-0.039
+-0.0312
+-0.0312
+-0.0156
+-0.0234
+-0.0078
+-0.0078
+0.0
+0.0
+0.0078
+0.0078
+0.0234

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_863.csv

@@ -0,0 +1,31 @@
+13.5
+13.0
+14.5
+15.0
+15.5
+18.5
+21.0
+25.0
+27.0
+30.0
+32.5
+34.5
+37.5
+39.5
+40.5
+44.0
+46.5
+49.0
+52.5
+54.5
+57.5
+57.0
+58.5
+59.0
+59.0
+57.5
+55.5
+54.5
+52.0
+50.0
+46.0

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_8720.csv

@@ -0,0 +1,21 @@
+0.2262
+0.2262
+0.2262
+0.2496
+0.2652
+0.2262
+0.1872
+0.1404
+0.078
+-0.0078
+-0.0624
+-0.0936
+-0.0858
+-0.0468
+-0.0078
+-0.0234
+-0.0702
+-0.117
+-0.1482
+-0.1404
+-0.117

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_9059.csv

@@ -0,0 +1,22 @@
+-0.3978
+-0.3042
+-0.234
+-0.156
+-0.078
+-0.0234
+0.0156
+0.0468
+0.0624
+0.078
+0.0624
+0.0468
+0.0078
+-0.0312
+-0.0936
+-0.1326
+-0.1794
+-0.2106
+-0.2496
+-0.273
+-0.3432
+-0.4446

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_9176.csv

@@ -0,0 +1,21 @@
+0.5093
+0.5054
+0.5024
+0.4976
+0.4936
+0.4888
+0.4829
+0.476
+0.4682
+0.4604
+0.4536
+0.4467
+0.4409
+0.436
+0.4321
+0.4281
+0.4252
+0.4223
+0.4193
+0.4164
+0.4154

Physiology-TS_MQA-Physiological_signal-Forecasting/raw_gt_data/output_Health_forecasting_9245.csv

@@ -0,0 +1,10 @@
+22.0
+22.0
+27.0
+27.0
+26.0
+10.0
+1.5
+4.0
+0.5
+7.0

README.md

@@ -1,3 +1,235 @@
----
-license: cc-by-nc-sa-4.0
----
+---
+license: cc-by-nc-sa-4.0
+---
+
+# SciTS: Scientific Time Series Understanding and Generation with LLMs
+
+
+This repository contains the official dataset for [**SciTS: Scientific Time Series Understanding and Generation with LLMs** (ICLR 2026)](https://openreview.net/forum?id=5YXccEP6uc). SciTS is a large-scale benchmark designed to evaluate the capabilities of large language models on complex scientific time series data. It spans 12 scientific disciplines, 43 distinct tasks, and includes 54,023 instances.
+
+![SciTS](./process/data_overview.jpg)
+
+## Dataset Structure
+
+The benchmark is organized into a main `meta_data.jsonl` file, a `process` directory for handling restricted datasets, and 38 individual dataset folders. Each folder is named using the convention: `Domain-DatasetName-Scene-Task`.
+
+```
+├── process/
+│   ├── process_ETT.py
+│   ├── process_iNaturalist.py
+│   ├── infer_template.py
+│   ├── eval.py
+│   └── requirements.txt
+├── Domain-DatasetName-Scene-Task_1/
+│   ├── raw_input_data/
+│   └── raw_gt_data/ (for generation tasks)
+├── Domain-DatasetName-Scene-Task_2/
+│   └── raw_input_data/
+...
+├── Domain-DatasetName-Scene-Task_38/
+│   ├── raw_input_data/
+│   └── raw_gt_data/
+└── meta_data.jsonl
+```
+
+- **`process/`**: Contains utility scripts, including `process_ETT.py` and `process_iNaturalist.py` for processing restricted datasets which cannot be released directly due to license restrictions, `infer_template.py` as an inference template, `eval.py` for evaluation, and `requirements.txt` for dependency installation.
+- **`Dataset Folders`**: Each of the 38 folders contains the raw time series data for a specific dataset. `raw_input_data` holds the input signals, while `raw_gt_data` (present only for generation tasks) holds the ground truth output signals.
+- **`meta_data.jsonl`**: A JSON Lines file containing metadata for every instance in the benchmark. Each line corresponds to one data sample.
+
+### Dataset Collection
+
+The 38 released datasets are listed below:
+
+| Domain | Dataset Folder Name | Task ID |
+| :--- | :--- | :--- |
+| Astronomy | `Astronomy-GWOSC_GW_Event-Gravitational_wave-Anomaly_detection+Event_localisation` | ASU01, ASG02 |
+| | `Astronomy-LEAVES-Light_curve-Classification` | ASU03 |
+| Earth Science | `Earth_Science-STEAD-Earthquake-Anomaly_detection+Event_localisation` | EAU01, EAG02 |
+| Bioacoustics | `Bioacoustics-Powdermill-Birds_vocalisation-Classification` | BIU01 |
+| | `Bioacoustics-MarmAudio-Marmoset_vocalisation-Classification` | BIU03 |
+| Meteorology | `Meteorology-TS_MQA-Weather-Anomaly_detection` | MEU01 |
+| | `Meteorology-TIMECAP-Rainfall-Anomaly_detection` | MEU02 |
+| | `Meteorology-MT_bench-Temperature-Forecasting` | MEG03 |
+| | `Meteorology-MT_bench-Temperature-MCQ` | MEU04 |
+| Economics | `Economics-FinMultiTime-Stock_closing_price-Forecasting` | ECG01 |
+| | `Economics-MT_bench-Stock_price-Forecasting` | ECG02 |
+| | `Economics-MT_bench-Stock-MCQ` | ECU03 |
+| Neuroscience | `Neuroscience-MDD-Depressive_disorder-Anomaly_detection` | NEU01 |
+| | `Neuroscience-TUEV-EEG_pattern-Classification` | NEU02 |
+| | `Neuroscience-TS_MQA-EEG_signal-Forecasting` | NEG03 |
+| | `Neuroscience-TS_MQA-EEG_signal-Imputation` | NEG04 |
+| | `Neuroscience-WBCIC_SHU-Motor_imagery-Classification` | NEU05 |
+| | `Neuroscience-Sleep-Sleep_staging-Classification` | NEU06 |
+| Energy | `Energy-NewsForecast-Electronic_load-Forecasting` | ENG01 |
+| | `Energy-TextETT-Sensor_signal_trend-Synthesis` | ENG03 |
+| | `Energy-TS_MQA-Comprehensive_electricity-Forecasting` | ENG04 |
+| | `Energy-TS_MQA-Comprehensive_electricity-Imputation` | ENG05 |
+| Physiology | `Physiology-PTB_XL-ECG_status-Classification` | PHU01 |
+| | `Physiology-TS_MQA-Physiological_signal-Forecasting` | PHG02 |
+| | `Physiology-TS_MQA-Physiological_signal-Imputation` | PHG03 |
+| | `Physiology-TS_MQA-ECG-Anomaly_detection` | PHU04 |
+| | `Physiology-TS_MQA-Gait_freezing-Anomaly_detection` | PHU05 |
+| | `Physiology-TS_MQA-Human_activity-Classification` | PHU06 |
+| Urbanism | `Urbanism-NewsForecast-Traffic_flow-Forecasting` | URG01 |
+| | `Urbanism-TS_MQA-Pedestrian_flow-Forecasting` | URG02 |
+| | `Urbanism-TS_MQA-Pedestrian_flow-Imputation` | URG03 |
+| | `Urbanism-TS_MQA-Traffic_flow-Anomaly_detection` | URU04 |
+| | `Urbanism-MetroTraffic-Traffic_volume-Forecasting` | URG05 |
+| Manufacturing | `Manufacturing-CWRU-Bearings_fault_location+Bearings_fault_size-Classification` | MFU01, MFU02 |
+| | `Manufacturing-MIMII_Due-Machine_malfunction-Anomaly_detection` | MFU03 |
+| Radar | `Radar-RadSeg-Coding_scheme-Classification` | RAU01 |
+| | `Radar-RadarCom-Modes_and_modulation-Classification` | RAU02 |
+| Math | `Math-Chaotic-Chaotic_system-Forecasting` | MAG01 |
+
+## `meta_data.jsonl` Format
+
+Each line in this file is a JSON object with the following structure, providing all necessary metadata to load and use a data sample.
+
+```json
+{
+    "task_id": ["TASK_ID"], // List of task IDs associated with this sample (e.g., ["ASU03"] or ["ASU01", "ASG02"] for merged datasets)
+    "id": "DATASET_ID", // Unique identifier of this sample within the dataset
+    "data_type": "csv"/"npy"/"wav"/"flac", // File format of the raw time series data
+    "input_ts":{
+        "num_channel": int, // Number of channels (dimensions) in the input signal
+        "channel_detail": [], // List of channel names, empty if none
+        "path": "raw_input_data/sample_001_input.npy",
+        "length": int, // Length of the input time series
+        "timestamps": [], // Auxiliary timestamp information, empty if none
+        "fs": int // Sampling frequency in Hz
+    },
+    "input_text": "INPUT_TEXT", // Textual prompt or task instruction provided as input
+    "gt_text": "GT_TEXT", // Ground truth textual answer (for understanding tasks; empty for generation tasks)
+    "gt_ts": {
+        "path": "raw_gt_data/sample_001_output.npy",
+        "length": int
+    },
+    "gt_result": { ... }, // Structured ground truth result; format varies by task type (see below)
+    "meta_data": {}  // Additional metadata from the original data source
+}
+```
+
+### `gt_result` Field Format
+
+The structure of the `gt_result` field varies depending on the task type. This field provides the original ground truth for metric computation.
+
+**1. MCQ**
+```json
+"gt_result": {
+    "answer": "TEXT" // The correct textual answer
+}
+```
+
+**2. Synthesis, Forecasting, Imputation**
+```json
+"gt_result": {
+    "num_channel": int, // Number of channels (dimensions) in the ground truth signal
+    "channel_detail": [], // List of channel names, empty if none
+    "timestamps": [] // Auxiliary timestamp information, empty if none
+}
+```
+
+**3. Classification**
+
+For the `CWRU` dataset, which involves two classification sub-tasks, the category keys in class_list and gt_class are `"diameter"` and `"position"` respectively. For all other classification tasks, the category key is `"default"`.
+
+```json
+"gt_result": {
+    "class_list": {
+        "default": ["class_A", "class_B"], // List of candidate classes for each category
+        ...
+    },
+    "gt_class": {
+        "default": ["GT_CLASS"], // Ground truth class label for each category
+        ...
+    }
+}
+```
+
+**4. Anomaly Detection**
+```json
+"gt_result": {
+    "contain": Boolean // Boolean indicating if the required event is present
+}
+```
+
+**5. Anomaly Detection + Event Localisation**
+
+For the `GWOSC GW Event` and `STEAD` datasets, each of which includes both an `Anomaly Detection` task and an `Event Localisation` task, the gt_result field is defined in the following combined format:
+
+```json
+"gt_result": {
+    "contain": Boolean, // Boolean indicating if the required event is present
+    "start_time": int // The event index if contain is true, else null
+}
+```
+
+## Handling Restricted Datasets
+
+Due to license restrictions, the **ETT** (`ENG02`) and **iNaturalist** (`BIU02`) datasets are not directly included in this repository. To use them, the user need to download the original data and run the provided processing scripts.
+
+**Step 1: Download the Data**
+
+- **ETT**: Download `ETTh1.csv` from the official repository: [https://github.com/zhouhaoyi/ETDataset](https://github.com/zhouhaoyi/ETDataset)
+- **iNaturalist**: Download the `Test Recordings` from the official repository: [https://github.com/visipedia/inat_sounds/tree/main/2024](https://github.com/visipedia/inat_sounds/tree/main/2024)
+
+**Step 2: Install Dependencies**
+
+Before running the processing scripts, install the required Python packages:
+
+```shell
+pip install -r process/requirements.txt
+```
+
+**Step 3: Run the Processing Script**
+
+Place the downloaded files into a local directory. Then, from the root of this repository, run the corresponding script to process the data into the standard benchmark format.
+
+- For ETT:
+  ```shell
+  python process/process_ETT.py --data_path /path/to/your/ETTh1.csv
+  ```
+
+- For iNaturalist:
+  ```shell
+  python process/process_iNaturalist.py --data_folder /path/to/your/iNaturalist/test
+  ```
+
+This will generate the `Energy-ETT-Transformer_sensor_signal-Forecasting` and `Bioacoustics-INaturalist-Animal_vocalisation-Classification` folders along with their `raw_input_data`, `raw_gt_data` subdirectories, as well as the processed test files.
+
+## Baseline Inference and Evaluation
+
+The `process` directory also includes scripts for running inference and evaluating the results.
+
+### Inference
+
+`process/infer_template.py`: Template code for the inference script. Implement the `initialize_model` function, then inference can be done by running:
+
+```shell
+python process/infer_template.py --scits_dir /path/to/scits_dir --output_dir /path/to/output_dir
+```
+
+### Evaluation
+
+`process/eval.py`: Evaluation script. Run:
+
+```shell
+python process/eval.py evaluate --infer_dir /path/to/infer_dir
+```
+
+The evaluation results will be saved to `/path/to/infer_dir/results/`.
+
+## Citation
+
+If you use the SciTS benchmark, please cite the paper:
+
+```bibtex
+@inproceedings{
+    wu2026scits,
+    title={Sci{TS}: {S}cientific Time Series Understanding and Generation with {LLM}s},
+    author={Wen Wu and Ziyang Zhang and Liwei Liu and Xuenan Xu and Jimin Zhuang and Ke Fan and Qitan Lv and Junlin Liu and Chen Zhang and Zheqi Yuan and Siyuan Hou and Tianyi Lin and Kai Chen and Bowen Zhou and Chao Zhang},
+    booktitle={The Fourteenth International Conference on Learning Representations},
+    year={2026},
+    url={https://openreview.net/forum?id=5YXccEP6uc}
+}
+```

process/eval.py

@@ -0,0 +1,584 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import fire
+import h5py
+from sklearn.metrics import accuracy_score, mean_absolute_error, f1_score
+
+from infer_eval_utils import read_time_series_data, concat_base_path, non_zero_rel_mae, DATASET_TO_TASK
+
+
+class Runner(object):
+
+    def multitask_classification(self,
+                                 infer_path: str = "",
+                                 gts: list = [],
+                                 preds: list = []):
+        tasks = gts[0].keys()
+        output_fpath = Path(
+            infer_path).parent / f"results/{Path(infer_path).stem}.json"
+        output_fpath.parent.mkdir(parents=True, exist_ok=True)
+        res_dict = {}
+        success = 0
+        fail = 0
+        for task in tasks:
+            correct_count = 0
+            for gt, pred in zip(gts, preds):
+                try:
+                    if pred[task] == gt[task][0] or pred[task].lower(
+                    ) == gt[task][0]:
+                        correct_count += 1
+                    success += 1
+                except:
+                    fail += 1
+            acc = correct_count / len(gts)
+            print(f"Accuracy for {task}: {acc}")
+            class_f1s = []
+            task_gts = [gt[task][0] for gt in gts]
+            labels = list(set(task_gts))
+            for label in labels:
+                # Find all samples with this true label
+                true_indices = [
+                    i for i, gt in enumerate(task_gts) if gt == label
+                ]
+                if len(true_indices) == 0:
+                    recall = 0.0
+                else:
+                    correct_predictions = 0
+                    for idx in true_indices:
+                        pred = preds[idx][task]
+                        gt = task_gts[idx]
+                        if pred == gt or pred.lower() == gt:
+                            correct_predictions += 1
+
+                    recall = correct_predictions / len(true_indices)
+
+                pred_indices = [
+                    i for i, pred in enumerate(preds)
+                    if pred[task].lower() == label or pred[task] == label
+                ]
+                if len(pred_indices) == 0:
+                    precision = 0.0
+                else:
+                    correct_predictions = 0
+                    for idx in pred_indices:
+                        pred = preds[idx][task]
+                        gt = task_gts[idx]
+                        if pred == gt or pred.lower() == gt:
+                            correct_predictions += 1
+                    precision = correct_predictions / len(pred_indices)
+
+                f1 = (2 * recall * precision) / (recall + precision + 1e-6)
+                class_f1s.append(f1)
+
+            res_dict[task] = {
+                "acc": acc,
+                "f1": f1,
+                "success": success,
+                "fail": fail,
+                "success_rate": success / (success + fail)
+            }
+
+        res_dict["overall"] = {
+            "f1": np.mean(class_f1s),
+            "acc": np.mean([r["acc"] for r in res_dict.values()]),
+        }
+
+        with open(output_fpath, "w") as writer:
+            json.dump(res_dict, writer, indent=4)
+            writer.write("\n")
+
+    def multichoice_classification(self,
+                                   infer_path: str = "",
+                                   gts: list = [],
+                                   preds: list = []):
+        all_labels = set()
+        for gt in gts:
+            if isinstance(gt, list):
+                all_labels.update(gt)
+            else:
+                all_labels.add(gt)
+
+        all_labels = sorted(list(all_labels))
+
+        # Convert ground truth and predictions to multi-label format
+        y_true_multilabel = []
+        y_pred_multilabel = []
+        success = 0
+        fail = 0
+        for gt, pred in zip(gts, preds):
+            # Process ground truth
+            if isinstance(gt, list):
+                gt_labels = gt
+            else:
+                gt_labels = [gt]
+
+            # Process predictions
+            while '\n\n' in pred:
+                pred = pred.replace('\n\n', '\n')
+            pred_labels = [x.strip() for x in pred.split("\n")]
+
+            # Convert to binary vectors
+            gt_binary = [
+                1 if label in gt_labels else 0 for label in all_labels
+            ]
+            pred_binary = []
+            for label in all_labels:
+                is_found = False
+                for pred_label in pred_labels:
+                    if pred_label == label or pred_label.lower() == label:
+                        is_found = True
+                        break
+                if is_found:
+                    pred_binary.append(1)
+                else:
+                    pred_binary.append(0)
+
+            y_true_multilabel.append(gt_binary)
+            y_pred_multilabel.append(pred_binary)
+
+        y_true_multilabel = np.array(y_true_multilabel)
+        y_pred_multilabel = np.array(y_pred_multilabel)
+
+        # Calculate F1 score for each class
+        f1_scores = []
+        for i, label in enumerate(all_labels):
+            f1 = f1_score(y_true_multilabel[:, i],
+                          y_pred_multilabel[:, i],
+                          zero_division=0)
+            f1_scores.append(f1)
+            print(f"F1 score for class {label}: {f1:.4f}")
+
+        # Calculate mean of F1 scores
+        macro_f1 = np.mean(f1_scores)
+        print(f"Macro F1 score (mean of all classes): {macro_f1:.4f}")
+
+        # Save results
+        output_fpath = Path(
+            infer_path).parent / f"results/{Path(infer_path).stem}.json"
+        output_fpath.parent.mkdir(parents=True, exist_ok=True)
+
+        results = {
+            "macro_f1": macro_f1,
+            "per_class_f1": dict(zip(all_labels, f1_scores))
+        }
+
+        with open(output_fpath, "w") as writer:
+            json.dump(results, writer, indent=4)
+            writer.write("\n")
+
+    def classification(self, infer_path: str = ""):
+        gts, preds = [], []
+        with open(infer_path, "r") as f:
+            for line in f:
+                item = json.loads(line)
+                if "id" not in item:
+                    continue
+                gts.append(item["ground_truth"])
+                preds.append(item["output"])
+
+        if any(isinstance(gt, list) for gt in gts):
+            return self.multichoice_classification(infer_path, gts, preds)
+
+        if isinstance(preds[0], dict):
+            return self.multitask_classification(infer_path, gts, preds)
+        # Custom comparison function: consider both exact match and case-insensitive match
+        # This is because LLM outputs sometimes capitalize the first letter to follow English grammar
+        correct_count = 0
+        for gt, pred in zip(gts, preds):
+            if pred == gt or pred.lower() == gt:
+                correct_count += 1
+
+        acc = correct_count / len(gts)
+        print(f"Accuracy: {acc}")
+
+        # Using the same case-insensitive matching as accuracy calculation
+        labels = list(set(gts))
+
+        # Manually calculate recall for each class
+        class_recalls = []
+        class_precisions = []
+        class_f1s = []
+        for label in labels:
+            # Find all samples with this true label
+            true_indices = [i for i, gt in enumerate(gts) if gt == label]
+            if len(true_indices) == 0:
+                recall = 0.0
+                class_recalls.append(0.0)
+            else:
+                # Calculate recall for this label
+                correct_predictions = 0
+                for idx in true_indices:
+                    pred = preds[idx]
+                    gt = gts[idx]
+                    if pred == gt or pred.lower() == gt:
+                        correct_predictions += 1
+
+                recall = correct_predictions / len(true_indices)
+                class_recalls.append(recall)
+
+            pred_indices = [
+                i for i, pred in enumerate(preds)
+                if pred.lower() == label or pred == label
+            ]
+            if len(pred_indices) == 0:
+                precision = 0.0
+                class_precisions.append(0.0)
+            else:
+                correct_predictions = 0
+                for idx in pred_indices:
+                    pred = preds[idx]
+                    gt = gts[idx]
+                    if pred == gt or pred.lower() == gt:
+                        correct_predictions += 1
+
+                precision = correct_predictions / len(pred_indices)
+                class_precisions.append(precision)
+
+            f1 = (2 * recall * precision) / (recall + precision + 1e-6)
+            class_f1s.append(f1)
+
+        output_fpath = Path(
+            infer_path).parent / f"results/{Path(infer_path).stem}.json"
+        output_fpath.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_fpath, "w") as writer:
+            json.dump({
+                "acc": acc,
+                "f1": np.mean(class_f1s),
+            },
+                      writer,
+                      indent=4)
+            writer.write("\n")
+
+    def mcq(self, infer_path: str = ""):
+        gts, preds = [], []
+        with open(infer_path, "r") as f:
+            for line in f:
+                item = json.loads(line)
+                if "id" not in item:
+                    continue
+                gts.append(item["ground_truth"])
+                preds.append(item["output"])
+
+        # Custom comparison function: consider both exact match and case-insensitive match
+        # This is because LLM outputs sometimes capitalize the first letter to follow English grammar
+        correct_count = 0
+        for gt, pred in zip(gts, preds):
+            if pred == gt or pred.lower() == gt:
+                correct_count += 1
+
+        acc = correct_count / len(gts)
+        print(f"Accuracy: {acc}")
+
+        # Calculate recall with custom matching logic
+        # Using the same case-insensitive matching as accuracy calculation
+        try:
+            labels = list(set(gts))
+
+            # Manually calculate recall for each class
+            class_recalls = []
+            for label in labels:
+                # Find all samples with this true label
+                true_indices = [i for i, gt in enumerate(gts) if gt == label]
+                if len(true_indices) == 0:
+                    class_recalls.append(0.0)
+                    continue
+
+                # Calculate recall for this label (using lenient matching)
+                correct_predictions = 0
+                for idx in true_indices:
+                    pred = preds[idx]
+                    gt = gts[idx]
+                    if pred == gt or pred.lower() == gt:
+                        correct_predictions += 1
+
+                recall = correct_predictions / len(true_indices)
+                class_recalls.append(recall)
+
+            # Calculate macro average recall
+            weighted_recall = np.mean(class_recalls)
+            print(f"Weighted Recall: {weighted_recall}")
+
+            output_fpath = Path(
+                infer_path).parent / f"results/{Path(infer_path).stem}.json"
+            output_fpath.parent.mkdir(parents=True, exist_ok=True)
+            with open(output_fpath, "w") as writer:
+                json.dump({
+                    "acc": acc,
+                    "uar": weighted_recall
+                },
+                          writer,
+                          indent=4)
+                writer.write("\n")
+
+        except Exception as e:
+            print(f"Error calculating Weighted Recall: {e}")
+            print(
+                "Possible reasons: labels are not numeric or contain non-numeric labels"
+            )
+
+    def anomaly_detection(self, infer_path: str = ""):
+        gts, preds = [], []
+        success, fail = 0, 0
+        with open(infer_path, "r") as f:
+            for line in f:
+                item = json.loads(line)
+                if "id" not in item:
+                    continue
+
+                if item["output"].lower() == "yes":
+                    preds.append(True)
+                elif item["output"].lower() == "no":
+                    preds.append(False)
+                else:
+                    fail += 1
+                    continue
+                success += 1
+                gts.append(item["ground_truth"])
+
+        correct_count = 0
+        for gt, pred in zip(gts, preds):
+            if pred == gt:
+                correct_count += 1
+        print(f"Success: {success}, Fail: {fail}")
+        acc = correct_count / len(gts)
+        print(f"Accuracy: {acc}")
+
+        f1 = f1_score(gts, preds)
+        print(f"F1 Score: {f1}")
+        output_fpath = Path(
+            infer_path).parent / f"results/{Path(infer_path).stem}.json"
+        output_fpath.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_fpath, "w") as writer:
+            json.dump({
+                "acc": acc,
+                "f1": f1,
+                "success": success,
+                "fail": fail
+            },
+                      writer,
+                      indent=4)
+            writer.write("\n")
+
+    def forecasting(self, infer_path: str = ""):
+        gt_arrs = []
+        pred_arrs = []
+        success = 0
+        fail = 0
+        with h5py.File(infer_path, "r") as f:
+            base_path = Path(f["base_path"][()].decode("utf-8"))
+            for id in f.keys():
+                try:
+                    if id not in [
+                            "base_path", "dataset_name", "domain", "task",
+                            "scene"
+                    ]:
+                        gt_path = concat_base_path(
+                            base_path,
+                            f[id]["gt_path"][()].decode("utf-8").strip("/"))
+                        gt_data = read_time_series_data(gt_path)
+                        gt_data = np.array(gt_data, dtype=np.float32)
+                        pred = f[id]["pred_result"][()]
+
+                        if pred.shape != gt_data.shape:
+                            raise ValueError(
+                                f"Pred shape {pred.shape} does not match gt shape {gt_data.shape}"
+                            )
+                        gt_arrs.append(gt_data.reshape(-1))
+                        pred_arrs.append(pred.reshape(-1))
+                        success += 1
+                except Exception as e:
+                    print(f"Error processing {id}: {e}")
+                    fail += 1
+
+        if len(gt_arrs) == 0:
+            mae = "N/A"
+            rel_mae = "N/A"
+        else:
+            gt_arrs = np.concatenate(gt_arrs)
+            pred_arrs = np.concatenate(pred_arrs)
+
+            # mse = mean_squared_error(gt_arrs, pred_arrs)
+            mae = mean_absolute_error(gt_arrs, pred_arrs)
+            rel_mae = non_zero_rel_mae(gt_arrs, pred_arrs)
+        print(
+            f"MAE: {mae}, REL_MAE: {rel_mae}, Success: {success}, Fail: {fail}"
+        )
+        output_fpath = Path(
+            infer_path).parent / f"results/{Path(infer_path).stem}.json"
+        output_fpath.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_fpath, "w") as writer:
+            json.dump(
+                {
+                    "rel_mae": rel_mae,
+                    "mae": mae,
+                    "success": success,
+                    "fail": fail,
+                    "success_rate": success / (success + fail)
+                },
+                writer,
+                indent=4)
+            writer.write("\n")
+
+    def synthesize(self, infer_path: str = ""):
+        return self.forecasting(infer_path)
+
+    def imputation(self, infer_path: str = ""):
+        gt_arrs = []
+        pred_arrs = []
+        success = 0
+        fail = 0
+        with h5py.File(infer_path, "r") as f:
+            base_path = Path(f["base_path"][()].decode("utf-8"))
+            for id in f.keys():
+                try:
+                    if id not in [
+                            "base_path", "dataset_name", "domain", "task",
+                            "scene"
+                    ]:
+                        # gt_path = base_path / f[id]["gt_path"][
+                        #     ()].decode("utf-8")
+                        gt_path = concat_base_path(
+                            base_path,
+                            f[id]["gt_path"][()].decode("utf-8").strip("/"))
+                        gt_data = read_time_series_data(gt_path)
+
+                        # input_path = base_path / f[id]["input_ts_path"][
+                        # ()].decode("utf-8")
+                        input_path = concat_base_path(
+                            base_path, f[id]["input_ts_path"][(
+                            )].decode("utf-8").strip("/"))
+                        input_data = read_time_series_data(input_path)
+
+                        pred_indices = np.where(input_data == "X")[0]
+                        pred = f[id]["pred_result"][()]
+
+                        pred = pred[pred_indices]
+                        gt_data = gt_data[pred_indices]
+                        if len(pred) != len(gt_data):
+                            length_mismatch += 1
+                        else:
+                            success += 1
+                        if len(pred) < len(gt_data):
+                            pred = pred[:len(gt_data)]
+                        if len(pred) > len(gt_data):
+                            gt_data = gt_data[:len(pred)]
+                        gt_arrs.append(gt_data)
+                        pred_arrs.append(pred)
+                        # success += 1
+                except Exception as e:
+                    print(f"Error processing {id}: {e}")
+                    fail += 1
+
+        gt_arrs = np.concatenate(gt_arrs)
+        pred_arrs = np.concatenate(pred_arrs)
+        # mse = mean_squared_error(gt_arrs, pred_arrs)
+        rel_mae = non_zero_rel_mae(gt_arrs, pred_arrs)
+        mae = mean_absolute_error(gt_arrs, pred_arrs)
+
+        print(
+            f"REL_MAE: {rel_mae}, MAE: {mae}, Success: {success}, Fail: {fail}"
+        )
+        output_fpath = Path(
+            infer_path).parent / f"results/{Path(infer_path).stem}.json"
+        output_fpath.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_fpath, "w") as writer:
+            json.dump(
+                {
+                    "rel_mae": rel_mae,
+                    "mae": mae,
+                    "success": success,
+                    "fail": fail,
+                    "success_rate": success / (success + fail)
+                },
+                writer,
+                indent=4)
+            writer.write("\n")
+
+    def event_detection(self, infer_path: str = ""):
+        event_gts, event_preds = [], []
+        seq_length = None
+        success = 0
+        total = 0
+        timestamp_gts, timestamp_preds = [], []
+        with open(infer_path, "r") as f:
+            for line in f:
+                item = json.loads(line)
+                if "id" not in item:
+                    seq_length = item["seq_length"]
+                    continue
+                event_gt = item["ground_truth"]["contain"]
+                event_gts.append(1 if event_gt else 0)
+
+                if "\n" in item["output"]:
+                    while '\n\n' in item["output"]:
+                        item["output"] = item["output"].replace('\n\n', '\n')
+                    event_pred, *timestamps = item["output"].split("\n")
+                else:
+                    event_pred = item["output"]
+                    timestamps = None
+                event_preds.append(1 if event_pred.lower() == "yes" else 0)
+
+                if event_gt:
+                    if "start_time" in item["ground_truth"]:
+                        gt_timestamps = [item["ground_truth"]["start_time"]]
+                    elif "start_time_p" in item["ground_truth"]:
+                        gt_timestamps = [
+                            item["ground_truth"]["start_time_p"],
+                            item["ground_truth"]["start_time_s"]
+                        ]
+
+                    if timestamps is None:
+                        pass
+                    else:
+                        try:
+                            assert len(timestamps) == len(gt_timestamps)
+                            for pred_timestamp, gt_timestamp in zip(
+                                    timestamps, gt_timestamps):
+                                pred_timestamp = eval(pred_timestamp)
+                                timestamp_preds.append(pred_timestamp)
+                                timestamp_gts.append(gt_timestamp)
+                            success += 1
+                        except Exception as e:
+                            print(str(e))
+                    total += 1
+
+        event_acc = accuracy_score(event_gts, event_preds)
+        event_f1 = f1_score(event_gts, event_preds)
+        timestamp_gts = np.array(timestamp_gts)
+        timestamp_preds = np.array(timestamp_preds)
+        mape = non_zero_rel_mae(timestamp_gts, timestamp_preds)
+        output_fpath = Path(
+            infer_path).parent / f"results/{Path(infer_path).stem}.json"
+        output_fpath.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_fpath, "w") as writer:
+            json.dump(
+                {
+                    "acc": event_acc,
+                    "f1": event_f1,
+                    "mape": mape,
+                    "success_rate": success / total
+                },
+                writer,
+                indent=4)
+            writer.write("\n")
+        print({
+            "acc": event_acc,
+            "f1": event_f1,
+            "mape": mape,
+            "success_rate": success / total
+        })
+
+    def evaluate(self, infer_dir: str):
+        for infer_path in Path(infer_dir).glob("*"):
+            if infer_path.is_dir():
+                continue
+            dataset_id = infer_path.stem
+            task = DATASET_TO_TASK[dataset_id]
+            print(f"evaluating {dataset_id} ...")
+            getattr(self, task)(infer_path)
+
+
+if __name__ == "__main__":
+    fire.Fire(Runner)

process/infer_eval_utils.py

@@ -0,0 +1,142 @@
+from pathlib import Path
+from typing import Sequence
+
+import numpy as np
+import librosa
+from sklearn.metrics import mean_absolute_percentage_error
+
+
+GENERATION_TASK_IDS = [
+    "MEG03",
+    "ECG01",
+    "ECG02",
+    "NEG03",
+    "NEG04",
+    "ENG01",
+    "ENG02",
+    "ENG03",
+    "ENG04",
+    "ENG05",
+    "PHG02",
+    "PHG03",
+    "URG01",
+    "URG02",
+    "URG03",
+    "URG05",
+    "MAG01",
+]
+
+IMPUTATION_TASK_IDS = [
+    "NEG04",
+    "ENG05",
+    "PHG03",
+    "URG03",
+]
+
+CLASSIFICATION_TASK_IDS = [
+    "ASU03",
+    "BIU01",
+    "BIU02",
+    "BIU03",
+    "NEU02",
+    "NEU05",
+    "NEU06",
+    "PHU01",
+    "PHU06",
+    "MFU01_MFU02",
+    "RAU01",
+    "RAU02",
+]
+
+EVENT_DETECTION_TASK_IDS = ["ASU01_ASG02", "EAU01_EAG02"]
+
+ANOMALY_DETECTION_TASK_IDS = [
+    "MEU01",
+    "MEU02",
+    "NEU01",
+    "PHU04",
+    "PHU05",
+    "URU04",
+    "MFU03",
+]
+
+MCQ_TASK_IDS = ["MEU04", "ECU03"]
+
+DATASET_TO_TASK = {
+    "ASU01_ASG02": "event_detection",
+    "ASU03": "classification",
+    "EAU01_EAG02": "event_detection",
+    "BIU01": "classification",
+    "BIU02": "classification",
+    "BIU03": "classification",
+    "MEU01": "anomaly_detection",
+    "MEU02": "anomaly_detection",
+    "MEG03": "forecasting",
+    "MEU04": "mcq",
+    "ECG01": "forecasting",
+    "ECG02": "forecasting",
+    "ECU03": "mcq",
+    "NEU01": "anomaly_detection",
+    "NEU02": "classification",
+    "NEG03": "forecasting",
+    "NEG04": "imputation",
+    "NEU05": "classification",
+    "NEU06": "classification",
+    "ENG01": "synthesize",
+    "ENG02": "forecasting",
+    "ENG03": "forecasting",
+    "ENG04": "forecasting",
+    "ENG05": "imputation",
+    "PHU01": "classification",
+    "PHG02": "forecasting",
+    "PHG03": "imputation",
+    "PHU04": "anomaly_detection",
+    "PHU05": "anomaly_detection",
+    "PHU06": "classification",
+    "URG01": "forecasting",
+    "URG02": "forecasting",
+    "URG03": "imputation",
+    "URU04": "anomaly_detection",
+    "URG05": "forecasting",
+    "MFU01_MFU02": "classification",
+    "MFU03": "anomaly_detection",
+    "RAU01": "classification",
+    "RAU02": "classification",
+    "MAG01": "forecasting"
+}
+
+
+def read_time_series_data(path: str | Path) -> Sequence:
+    path_str = path.__str__()
+    data = []
+    if path_str.endswith(".csv"):
+        with open(path) as raw_data_reader:
+            for line in raw_data_reader.readlines():
+                line = line.strip("\ufeff")
+                if "," in line:
+                    data.append(line.strip().split(","))
+                else:
+                    data.append(line.strip())
+        if "X" not in data:
+            data = np.array(data, dtype=np.float32)
+        else:
+            data = np.array(data)
+    elif path_str.endswith(".npy"):
+        data = np.load(path)
+    elif path_str.endswith(".wav") or path_str.endswith(".flac"):
+        data, _ = librosa.core.load(path, mono=False)
+    else:
+        raise ValueError(f"Unsupported data type {path_str.endswith()}")
+    return data
+
+
+def concat_base_path(base_path: Path, path: str) -> Path:
+    if (base_path / path).exists():
+        return base_path / path
+    else:
+        return base_path.parent / path
+
+
+def non_zero_rel_mae(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    idxs = np.where(y_true != 0)[0]
+    return mean_absolute_percentage_error(y_true[idxs], y_pred[idxs])

process/infer_template.py

@@ -0,0 +1,296 @@
+import json
+import random
+from pathlib import Path
+from typing import Sequence, Callable
+
+import fire
+import h5py
+import numpy as np
+from tqdm import tqdm
+
+from infer_eval_utils import (
+    read_time_series_data,
+    GENERATION_TASK_IDS, 
+    CLASSIFICATION_TASK_IDS, 
+    EVENT_DETECTION_TASK_IDS, 
+    ANOMALY_DETECTION_TASK_IDS,
+    MCQ_TASK_IDS, 
+    IMPUTATION_TASK_IDS
+)
+
+
+def read_raw_data(path: str | None) -> Sequence:
+    if path is None:
+        return []
+
+    return read_time_series_data(path)
+
+
+def transform_raw_data_single_channel(raw_data: list | np.ndarray,
+                                      dataset_id: str) -> str:
+
+    if dataset_id in GENERATION_TASK_IDS:
+        data_str_list = []
+        for x in raw_data:
+            if x != "X":
+                data_str_list.append(f"{float(x):.3f}")
+            else:
+                data_str_list.append(x)
+        data_text = " ".join(data_str_list)
+    else:
+        data_text = " ".join([f"{float(x):.3f}" for x in raw_data])
+
+    return data_text
+
+
+def transform_raw_data_to_text(raw_data: list | np.ndarray, dataset_id: str,
+                               channel_detail: list[str]) -> str:
+
+    if isinstance(raw_data, np.ndarray):
+        if raw_data.ndim > 1 and raw_data.shape[1] > 1 and len(
+                channel_detail) == 0:
+            channel_detail = [f"channel {i}" for i in range(raw_data.shape[1])]
+
+        if len(channel_detail) <= 1:
+            data_text = transform_raw_data_single_channel(raw_data, dataset_id)
+        else:
+            data_text = ""
+            for channel_idx, channel_name in enumerate(channel_detail):
+                channel_data = raw_data[:, channel_idx]
+                channel_data_text = transform_raw_data_single_channel(
+                    channel_data, dataset_id)
+                data_text += f"{channel_name}: {channel_data_text} "
+    else:
+        data_text = transform_raw_data_single_channel(raw_data, dataset_id)
+    return data_text
+
+
+def transform_gt_data_to_text(gt_data: list | np.ndarray,
+                              dataset_id: str) -> str:
+    gt_data = np.array(gt_data)
+    if gt_data.ndim == 1:
+        data_text = transform_raw_data_single_channel(gt_data, dataset_id)
+    else:
+        data_text = ""
+        for channel_idx in range(gt_data.shape[1]):
+            channel_data = gt_data[:, channel_idx]
+            channel_data_text = transform_raw_data_single_channel(
+                channel_data, dataset_id)
+            data_text += f"{channel_data_text}\n"
+
+    return data_text
+
+
+def get_extra_instruction(dataset_id: str, ) -> str:
+    extra_instruction = ""
+    if dataset_id == "ASU01_ASG02":
+        extra_instruction = "Answer yes or no in the first line. If the Gravitational Wave is detected, answer the index of the starting time point in the second line."
+    elif dataset_id == "EAU01_EAG02":
+        extra_instruction = "Answer yes or no in the first line. If an Earthquake event is detected, answer the starting time point index of the P-wave in the second line, " \
+                            "answer the starting time point index of the S-wave in the third line."
+    elif dataset_id == "MFU01_MFU02":
+        extra_instruction = "Output the diameter in the first line, and the position in the second line."
+    elif dataset_id == "PHU01":
+        extra_instruction = "Give each answer in a line. For example, if the answer is ['NORM', 'MI'], you should output: NORM\nMI."
+    elif dataset_id == "MAG01":
+        extra_instruction = "Give answer of each channel in a line so the number of predicted time points in each line should match the given one. For example, if " \
+            "it is required to predict the next 5 time points, and the predicted x0, x1, x2 are [[0.1, 0.2, 0.3, 0.4, 0.5], [0.4, 0.5, 0.6, 0.7, 0.8], [0.7, 0.8, 0.9, 0.1, 0.2]], " \
+            "you should output: 0.1 0.2 0.3 0.4 0.5\n0.4 0.5 0.6 0.7 0.8\n0.7 0.8 0.9 0.1 0.2."
+    elif dataset_id in ANOMALY_DETECTION_TASK_IDS:
+        extra_instruction = "Answer yes if anomaly points are detected, and no if there are only normal points."
+    elif dataset_id in GENERATION_TASK_IDS:
+        extra_instruction = "Output the values separated by spaces."
+    return extra_instruction
+
+
+def extract_gt(data: dict, dataset_id: str) -> str | dict | Path:
+    if dataset_id in CLASSIFICATION_TASK_IDS:
+        gt = data["gt_result"]["gt_class"]
+        if isinstance(gt, dict) and len(gt) == 1:
+            gt = gt["default"]
+        if isinstance(gt, list) and len(gt) == 1:
+            gt = gt[0]
+    elif dataset_id in GENERATION_TASK_IDS:
+        gt = data["gt_ts"]["path"].strip("/")
+    elif dataset_id in EVENT_DETECTION_TASK_IDS:
+        gt = data["gt_result"]
+    elif dataset_id in ANOMALY_DETECTION_TASK_IDS:
+        gt = data["gt_result"]["contain"]
+    elif dataset_id in MCQ_TASK_IDS:
+        gt = data["gt_result"]["answer"]
+    else:
+        raise ValueError(f"Unsupported dataset id: {dataset_id}")
+    return gt
+
+
+def initialize_model() -> Callable:
+    """
+    Initialize the model here. The model can be called by:
+    
+    ```python
+    response = model(prompt) 
+    # or
+    response = model(prompt, max_tokens=max_tokens)  # to limit the response length
+    ```
+    """
+    pass
+
+
+def infer_dataset(model: Callable, dataset_data: list, scits_dir: Path,
+                  dataset_id: str, output_path: Path):
+    print(f"Inferring {dataset_id}")
+
+    if dataset_id in GENERATION_TASK_IDS:
+        ext = "h5"
+    else:
+        ext = "jsonl"
+
+    output_path = Path(output_path) / f"{dataset_id}.{ext}"
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    completed_ids = []
+
+    if str(output_path).endswith(".jsonl"):
+        has_metadata = False
+
+    if output_path.exists():
+        if str(output_path).endswith(".jsonl"):
+            with open(output_path, 'r') as f:
+                for line in f.readlines():
+                    data = json.loads(line)
+                    if "id" in data:
+                        completed_ids.append(data["id"])
+                    else:
+                        has_metadata = True
+        elif str(output_path).endswith(".h5"):
+            with h5py.File(output_path, 'r') as f:
+                completed_ids = list(f.keys())
+
+    completed_ids = set(completed_ids)
+    random.shuffle(dataset_data)
+    dataset_data = dataset_data[:10]
+
+    try:
+        seq_length = dataset_data[0]["input_ts"]["length"]
+    except:
+        seq_length = None
+
+    for sample in tqdm(dataset_data):
+        id = sample["id"].replace(
+            "/", "%2F")  # to avoid errors related to "/" in hdf5
+
+        if id in completed_ids:
+            continue
+
+        # Load raw data
+        if sample["input_ts"] is None:
+            raw_data_path = None
+            channel_detail = None
+        else:
+            raw_data_path = scits_dir / sample["input_ts"]["path"].strip("/")
+            channel_detail = sample["input_ts"]["channel_detail"]
+
+        raw_data = read_raw_data(raw_data_path)
+        raw_data_text = transform_raw_data_to_text(raw_data, dataset_id,
+                                                   channel_detail)
+
+        gt = extract_gt(sample, dataset_id)
+        extra_instruction = get_extra_instruction(dataset_id)
+
+        if dataset_id in GENERATION_TASK_IDS:
+            # give max_tokens to save cost for generation tasks
+            gt_data = read_time_series_data(scits_dir / gt)
+            gt_data_text = transform_gt_data_to_text(
+                gt_data, dataset_id)
+            max_tokens = len(gt_data_text)
+        else:
+            max_tokens = None
+
+        prompt_text = f'{sample["input_text"]} {extra_instruction} Give me the answer directly, ' \
+                    f'without any other extra content (including punctuation). ' \
+                    f'{raw_data_text}'
+        output_text = model(text=prompt_text, max_tokens=max_tokens)
+        # print(f"output_text: {output_text}")
+
+        if dataset_id not in GENERATION_TASK_IDS:
+            with open(output_path, 'a') as writer:
+                if not has_metadata:
+                    metadata = {}
+                    if dataset_id in EVENT_DETECTION_TASK_IDS:
+                        metadata["seq_length"] = seq_length
+                    writer.write(json.dumps(metadata) + "\n")
+                    has_metadata = True
+
+                pred_results = output_text
+                if "class_list" in sample["gt_result"] and isinstance(
+                        sample["gt_result"]["class_list"], dict) and len(
+                            sample["gt_result"]["class_list"]) > 1:
+                    if len(output_text.split("\n")) != len(
+                            sample["gt_result"]["class_list"]):
+                        pred_results = "NA"
+                    else:
+                        pred_results = {}
+                        for class_name, pred_result in zip(
+                                sample["gt_result"]["class_list"],
+                                output_text.split("\n")):
+                            pred_results[class_name] = pred_result
+                writer.write(
+                    json.dumps({
+                        "id": id,
+                        "output": pred_results,
+                        "ground_truth": gt
+                    }) + "\n")
+        else:
+            if "\n" not in output_text:
+                pred_result = np.fromstring(output_text.strip(),
+                                            dtype=np.float32,
+                                            sep=' ')
+            else:
+                try:
+                    pred_result = np.vstack([
+                        np.fromstring(x.strip(), dtype=np.float32, sep=' ')
+                        for x in output_text.split("\n")
+                    ]).transpose()
+                except ValueError:
+                    pred_result = np.array([])
+
+            with h5py.File(output_path, 'a') as writer:
+                writer[f"{id}/pred_result"] = pred_result
+                writer[f"{id}/gt_path"] = gt.__str__().encode("utf-8")
+                if dataset_id in IMPUTATION_TASK_IDS:
+                    writer[f"{id}/input_ts_path"] = sample["input_ts"][
+                        "path"].strip("/").encode("utf-8")
+                if "base_path" not in writer:
+                    writer["base_path"] = scits_dir.__str__().encode("utf-8")
+
+
+
+def infer(
+    scits_dir: str,
+    output_dir: str,
+):
+
+    # Initialize caller
+    model: Callable = initialize_model()
+
+    scits_dir = Path(scits_dir)
+    output_dir = Path(output_dir)
+    dataset_data = []
+    prev_dataset_id = None
+    with open(scits_dir / "meta_data.jsonl", 'r') as f:
+        for line in f.readlines():
+            sample = json.loads(line)
+            dataset_id = "_".join(sample["task_id"])
+
+            if dataset_id != prev_dataset_id:
+                if prev_dataset_id is not None:
+                    infer_dataset(model, dataset_data, scits_dir, prev_dataset_id,
+                                  output_dir)
+                dataset_data = []
+                prev_dataset_id = dataset_id
+            dataset_data.append(sample)
+
+    infer_dataset(model, dataset_data, scits_dir, prev_dataset_id, output_dir)
+
+
+if __name__ == '__main__':
+    fire.Fire(infer)

process/process_ETT.py

@@ -0,0 +1,86 @@
+import pandas as pd
+import os
+from tqdm import tqdm
+import argparse
+
+def main():
+    """
+    Main function to process CSV data and generate input and gt data files for ETT forecasting.
+    """
+    # Set up argument parser
+    parser = argparse.ArgumentParser(description="Process ETT forecasting data.")
+    parser.add_argument("--data_path", type=str, required=True, help="Path to the ETTh1.csv file.")
+    args = parser.parse_args()
+
+    try:
+        # Define the source folder containing the original files
+        csv_file_path = args.data_path
+        
+        # Read the CSV file into a DataFrame
+        df = pd.read_csv(csv_file_path)
+
+        # Define target folders for input and ground truth data
+        target_folder = "Energy-ETT-Transformer_sensor_signal-Forecasting"
+        input_data_path = os.path.join(target_folder, "raw_input_data")
+        gt_data_path = os.path.join(target_folder, "raw_gt_data")
+        
+        # Create directories if they don't exist
+        os.makedirs(input_data_path, exist_ok=True)
+        os.makedirs(gt_data_path, exist_ok=True)
+
+        # Define sequence and prediction lengths
+        seq_len_list = [96, 96]
+        pred_len_list = [96, 720]
+        label = 0  # No overloap
+        
+        # Specify the type of data to generate (e.g., "train", "val", "test")
+        generate_data_type = "test"
+
+        # Iterate over sequence and prediction lengths
+        for seq_len, pred_len in zip(seq_len_list, pred_len_list):
+
+            # Define start and end indices for different data types
+            start_idx = {
+                "train": 0,
+                "val": 12 * 30 * 24 - pred_len,
+                "test": (12 + 4) * 30 * 24 - pred_len,
+            }
+
+            end_idx = {
+                "train": 12 * 30 * 24 - seq_len - pred_len,
+                "val": (12 + 4) * 30 * 24 - seq_len - pred_len,
+                "test": (12 + 8) * 30 * 24 - seq_len - pred_len,
+            }
+
+            # Iterate over the specified range of indices
+            for i in tqdm(range(start_idx[generate_data_type], end_idx[generate_data_type] + 1), desc=f"Generating data: context_length: {seq_len}, prediction_length: {pred_len}"):
+                # Extract input and gt data
+                data_input = df.iloc[i : i + seq_len]
+                data_gt = df.iloc[i + seq_len : i + seq_len + pred_len]
+                
+                # Save input and gt data to CSV files, select 'OT' column
+                data_input[['OT']].to_csv(
+                    os.path.join(input_data_path, f'seq{seq_len}_label{label}_pred{pred_len}_index{i}_input_ts_OT.csv'),
+                    index=False,
+                    header=False,
+                    encoding='utf-8'
+                )
+                data_gt[['OT']].to_csv(
+                    os.path.join(gt_data_path, f'seq{seq_len}_label{label}_pred{pred_len}_index{i}_target_ts_OT.csv'),
+                    index=False,
+                    header=False,
+                    encoding='utf-8'
+                )
+
+    except FileNotFoundError:
+        print(f"Error: File {csv_file_path} not found. Please check the path or filename.")
+    except pd.errors.EmptyDataError:
+        print(f"Error: File {csv_file_path} is empty.")
+    except pd.errors.ParserError:
+        print(f"Error: File {csv_file_path} is not a valid CSV file.")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+
+
+if __name__ == "__main__":
+    main()

process/process_iNaturalist.py

@@ -0,0 +1,65 @@
+import json
+import os
+import shutil
+from tqdm import tqdm
+import argparse
+
+def read_jsonl(path):
+    data_list = []
+    try:
+        with open(path, "r", encoding="utf-8") as file:
+            for line in tqdm(file, desc="Reading JSONL file"):
+                data = json.loads(line)
+                data_list.append(data)
+        return data_list
+    except FileNotFoundError:
+        raise FileNotFoundError(f"Error: File {path} not found.")
+    except json.JSONDecodeError:
+        raise json.JSONDecodeError(f"Error: Invalid JSON format in file {path}.")
+    except Exception as e:
+        raise Exception(f"An unexpected error occurred while reading {path}: {e}")
+
+def main():
+    """
+    Main function to process metadata and copy relevant files from iNaturalist test data.
+    """
+    # Set up argument parser
+    parser = argparse.ArgumentParser(description="Process iNaturalist data.")
+    parser.add_argument("--data_folder", type=str, required=True, help="Path to the iNaturalist test folder.")
+    args = parser.parse_args()
+
+    try:
+        # Define the source folder containing the original files
+        data_folder = args.data_folder
+        
+        meta_data = read_jsonl("meta_data.jsonl")
+
+        # Copying iNaturalist test data in the metadata
+        for data in tqdm(meta_data, desc="Copying iNaturalist test data"):
+            if data["task_id"][0] == "BIU02":
+                tmp_path = data["input_ts"]["path"]
+                target_folder = os.path.dirname(tmp_path)
+                
+                # Create the target folder if it doesn't exist
+                os.makedirs(target_folder, exist_ok=True)
+                
+                # Extract the file name and parent folder from the path
+                data_name = os.path.basename(tmp_path).split("_")[-1]
+                folder = os.path.basename(tmp_path).replace(data_name, "")[:-1]
+                
+                # Copy the file if it doesn't exist in the target path
+                if not os.path.exists(tmp_path):
+                    source_path = os.path.join(data_folder, os.path.join(folder, data_name))
+                    try:
+                        shutil.copy(source_path, tmp_path)
+                    except FileNotFoundError:
+                        print(f"Warning: Source file {source_path} not found. Skipping.")
+                    except Exception as e:
+                        print(f"Warning: Failed to copy {source_path} to {tmp_path}. Error: {e}")
+
+    except Exception as e:
+        print(f"An error occurred during execution: {e}")
+
+
+if __name__ == "__main__":
+    main()

process/requirements.txt

@@ -0,0 +1,7 @@
+pandas
+numpy
+librosa
+scikit-learn
+fire
+h5py
+tqdm