feat: 🎸 support time series classification task

Author: yisongfu

README.md

@@ -40,6 +40,8 @@
 
 $\text{BasicTS}^{+}$ (**Basic** **T**ime **S**eries) is a benchmark library and toolkit designed for time series forecasting. It now supports a wide range of tasks and datasets, including spatial-temporal forecasting and long-term time series forecasting. It covers various types of algorithms such as statistical models, machine learning models, and deep learning models, making it an ideal tool for developing and evaluating time series forecasting models. You can find detailed tutorials in [Getting Started](./tutorial/getting_started.md).
 
+🎉 **Update (Aug 2025):** BasicTS now supports **time series classification tasks and the UEA dataset!** Check out [how to use BasicTS for classification tasks](./tutorial/time_series_classification_cn.md).
+
 🎉 **Update (June 2025):** Adds six LTSF baselines: CARD, TimeXer, Bi-Mamba, ModernTCN, S-D-Mamba, and S4.
 
 🎉 **Update (May 2025):** BasicTS now supports training universal forecasting models—such as **TimeMoE** and **ChronosBolt**—with the [BLAST](https://arxiv.org/abs/2505.17871) corpus. BLAST enables **faster convergence**, **notable reductions in computational cost**, and superior performance even with limited resources. See [here](./tutorial/training_with_BLAST.md).  

README_CN.md

@@ -41,6 +41,8 @@
 
 $\text{BasicTS}^{+}$ (**Basic** **T**ime **S**eries) 是一个面向时间序列预测的基准库和工具箱，现已支持时空预测、长序列预测等多种任务与数据集，涵盖统计模型、机器学习模型、深度学习模型等多类算法，为开发和评估时间序列预测模型提供了理想的工具。你可以在[快速上手](./tutorial/getting_started_cn.md)找到详细的教程。
 
+🎉 **更新（2025年8月）：BasicTS现已支持时间序列分类任务和UEA数据集!** 在这里了解[使用BasicTS进行分类任务](./tutorial/time_series_classification_cn.md)。
+
 🎉 **更新（2025年6月）：** 添加了6个长序列预测基线：CARD、TimeXer、Bi-Mamba、ModernTCN、S-D-Mamba、S4。
 
 🎉 **更新（2025年5月）：** BasicTS 现已支持使用 [BLAST](https://arxiv.org/abs/2505.17871) 语料库训练通用预测模型（例如 **TimeMoE** 和 **ChronosBolt**）。BLAST 能够实现 **更快的收敛速度**、**显著降低计算成本**，并且即使在资源有限的情况下也能获得卓越性能。[查看](./tutorial/training_with_BLAST_cn.md)。

baselines/iTransformer/JapaneseVowels.py

@@ -0,0 +1,135 @@
+import os
+import sys
+
+from easydict import EasyDict
+
+from basicts.data import UEADataset
+from basicts.metrics import accuracy
+from basicts.runners import SimpleTimeSeriesClassificationRunner
+from basicts.utils import load_dataset_desc
+
+from .arch import iTransformer
+
+sys.path.append(os.path.abspath(__file__ + "/../../.."))
+
+############################## Hot Parameters ##############################
+# Dataset & Metrics configuration
+DATA_NAME = "JapaneseVowels"  # Dataset name
+desc = load_dataset_desc(os.path.join("UEA", DATA_NAME))
+INPUT_LEN = desc["seq_len"]
+NUM_CLASSES = desc["num_classes"]
+NULL_VAL = 0.0
+# Model architecture and parameters
+MODEL_ARCH = iTransformer
+NUM_NODES = desc["num_nodes"]
+MODEL_PARAM = {
+    "task_name": "classification",
+    "num_classes": NUM_CLASSES,
+    "enc_in": NUM_NODES,                        # num nodes
+    "dec_in": NUM_NODES,
+    "c_out": NUM_NODES,
+    "seq_len": INPUT_LEN,
+    "label_len": INPUT_LEN/2,       # start token length used in decoder
+    "pred_len": 0,         # prediction sequence length
+    "factor": 3, # attn factor
+    "d_model": 128,
+    "moving_avg": 25,                           # window size of moving average. This is a CRUCIAL hyper-parameter.
+    "n_heads": 8,
+    "e_layers": 3,                              # num of encoder layers
+    "d_ff": 256,
+    "distil": True,
+    "sigma" : 0.2,
+    "dropout": 0.1,
+    "freq": "h",
+    "use_norm": True,
+    "output_attention": False,
+    "embed": "timeF",                           # [timeF, fixed, learned]
+    "activation": "gelu",
+    }
+NUM_EPOCHS = 20
+
+############################## General Configuration ##############################
+CFG = EasyDict()
+# General settings
+CFG.DESCRIPTION = "An Example Config"
+CFG.GPU_NUM = 1 # Number of GPUs to use (0 for CPU mode)
+# Runner
+CFG.RUNNER = SimpleTimeSeriesClassificationRunner
+
+############################## Dataset Configuration ##############################
+CFG.DATASET = EasyDict()
+# Dataset settings
+CFG.DATASET.NAME = DATA_NAME
+CFG.DATASET.TYPE = UEADataset
+CFG.DATASET.NUM_CLASSES = NUM_CLASSES
+CFG.DATASET.PARAM = EasyDict({
+    "dataset_name": DATA_NAME,
+    "train_val_test_ratio": None, # None for UEA datasets
+    # "mode" is automatically set by the runner
+})
+
+############################## Model Configuration ##############################
+CFG.MODEL = EasyDict()
+# Model settings
+CFG.MODEL.NAME = MODEL_ARCH.__name__
+CFG.MODEL.ARCH = MODEL_ARCH
+CFG.MODEL.PARAM = MODEL_PARAM
+
+############################## Metrics Configuration ##############################
+
+CFG.METRICS = EasyDict()
+# Metrics settings
+CFG.METRICS.FUNCS = EasyDict({
+                                "Accuracy": accuracy
+                            })
+CFG.METRICS.TARGET = "Accuracy"
+CFG.METRICS.NULL_VAL = NULL_VAL
+
+############################## Training Configuration ##############################
+CFG.TRAIN = EasyDict()
+CFG.TRAIN.NUM_EPOCHS = NUM_EPOCHS
+CFG.TRAIN.CKPT_SAVE_DIR = os.path.join(
+    "checkpoints",
+    MODEL_ARCH.__name__,
+    "_".join([DATA_NAME, str(CFG.TRAIN.NUM_EPOCHS)])
+)
+# CFG.TRAIN.LOSS = nn.CrossEntropyLoss()
+# Optimizer settings
+CFG.TRAIN.OPTIM = EasyDict()
+CFG.TRAIN.OPTIM.TYPE = "Adam"
+CFG.TRAIN.OPTIM.PARAM = {
+    "lr": 0.001,
+}
+# Learning rate scheduler settings
+CFG.TRAIN.LR_SCHEDULER = EasyDict()
+CFG.TRAIN.LR_SCHEDULER.TYPE = "MultiStepLR"
+CFG.TRAIN.LR_SCHEDULER.PARAM = {
+    "milestones": [1, 25, 50],
+    "gamma": 0.5
+}
+CFG.TRAIN.CLIP_GRAD_PARAM = {
+    "max_norm": 5.0
+}
+# Train data loader settings
+CFG.TRAIN.DATA = EasyDict()
+CFG.TRAIN.DATA.BATCH_SIZE = 16
+CFG.TRAIN.DATA.SHUFFLE = True
+
+############################## Validation Configuration ##############################
+CFG.VAL = EasyDict()
+CFG.VAL.INTERVAL = 1
+CFG.VAL.DATA = EasyDict()
+CFG.VAL.DATA.BATCH_SIZE = 16
+
+############################## Test Configuration ##############################
+CFG.TEST = EasyDict()
+CFG.TEST.INTERVAL = 1
+CFG.TEST.DATA = EasyDict()
+CFG.TEST.DATA.BATCH_SIZE = 16
+
+############################## Evaluation Configuration ##############################
+
+CFG.EVAL = EasyDict()
+
+# Evaluation parameters
+CFG.EVAL.USE_GPU = True # Whether to use GPU for evaluation. Default: True

baselines/iTransformer/arch/itransformer_arch.py

@@ -4,7 +4,6 @@
 from .Transformer_EncDec import Encoder, EncoderLayer
 from .SelfAttention_Family import FullAttention, AttentionLayer
 from .Embed import DataEmbedding_inverted
-import numpy as np
 from basicts.utils import data_transformation_4_xformer
 
 class iTransformer(nn.Module):
@@ -13,28 +12,28 @@ class iTransformer(nn.Module):
     Official Code: https://github.com/thuml/iTransformer
     Link: https://arxiv.org/abs/2310.06625
     Venue: ICLR 2024
-    Task: Long-term Time Series Forecasting
+    Task: Long-term Time Series Forecasting, Time Series Classification
     """
     def __init__(self, **model_args):
-        super(iTransformer, self).__init__()
+        super().__init__()
         self.pred_len = model_args['pred_len']
         self.seq_len = model_args['seq_len']
         self.output_attention = model_args['output_attention']
         self.enc_in = model_args['enc_in']
         self.dec_in = model_args['dec_in']
         self.c_out = model_args['c_out']
-        self.factor = model_args["factor"]
+        self.factor = model_args['factor']
         self.d_model = model_args['d_model']
         self.n_heads = model_args['n_heads']
         self.d_ff = model_args['d_ff']
         self.embed = model_args['embed']
-        self.freq = model_args["freq"]
-        self.dropout = model_args["dropout"]
+        self.freq = model_args['freq']
+        self.dropout = model_args['dropout']
         self.activation = model_args['activation']
         self.e_layers = model_args['e_layers']
-        self.d_layers = model_args['d_layers']
+        self.use_norm = model_args['use_norm']
+        self.task_name = model_args['task_name']
 
-        self.use_norm =model_args['use_norm']
         # Embedding
         self.enc_embedding = DataEmbedding_inverted(self.seq_len, self.d_model, self.embed, self.freq,
                                                     self.dropout)
@@ -54,7 +53,16 @@ def __init__(self, **model_args):
             ],
             norm_layer=torch.nn.LayerNorm(self.d_model)
         )
-        self.projector = nn.Linear(self.d_model, self.pred_len, bias=True)
+        if self.task_name == 'forecast':
+            self.projector = nn.Linear(self.d_model, self.pred_len, bias=True)
+
+        elif self.task_name == 'classification':
+            self.num_classes = model_args['num_classes']
+            self.act = F.gelu
+            self.dropout = nn.Dropout(self.dropout)
+            self.projector = nn.Linear(self.d_model * self.enc_in, self.num_classes)
+        else:
+            raise ValueError(f"Task name {self.task_name} is not supported.")
 
     def forward_xformer(self, x_enc: torch.Tensor, x_mark_enc: torch.Tensor, x_dec: torch.Tensor,
                         x_mark_dec: torch.Tensor,
@@ -103,9 +111,23 @@ def forward(self, history_data: torch.Tensor, future_data: torch.Tensor, batch_s
             torch.Tensor: outputs with shape [B, L2, N, 1]
         """
 
-        x_enc, x_mark_enc, x_dec, x_mark_dec = data_transformation_4_xformer(history_data=history_data,
-                                                                             future_data=future_data,
-                                                                             start_token_len=0)
-        #print(x_mark_enc.shape, x_mark_dec.shape)
-        prediction = self.forward_xformer(x_enc=x_enc, x_mark_enc=x_mark_enc, x_dec=x_dec, x_mark_dec=x_mark_dec)
-        return prediction.unsqueeze(-1)
+        if self.task_name == 'forecast':
+            x_enc, x_mark_enc, x_dec, x_mark_dec = data_transformation_4_xformer(history_data=history_data,
+                                                                                future_data=future_data,
+                                                                                start_token_len=0)
+
+            prediction = self.forward_xformer(x_enc=x_enc, x_mark_enc=x_mark_enc, x_dec=x_dec, x_mark_dec=x_mark_dec)
+
+        elif self.task_name == 'classification':
+            enc_out = self.enc_embedding(history_data[..., 0], None)
+            enc_out, attns = self.encoder(enc_out, attn_mask=None)
+            # Output
+            output = self.act(enc_out)  # the output transformer encoder/decoder embeddings don't include non-linearity
+            output = self.dropout(output)
+            output = output.reshape(output.shape[0], -1)  # (batch_size, c_in * d_model)
+            prediction = self.projector(output)  # (batch_size, num_classes)
+
+        else:
+            raise ValueError(f"Task name {self.task_name} is not supported.")
+
+        return prediction

basicts/data/__init__.py

@@ -1,4 +1,7 @@
 from .base_dataset import BaseDataset
+from .simple_tsc_dataset import TimeSeriesClassificationDataset
 from .simple_tsf_dataset import TimeSeriesForecastingDataset
+from .uea_dataset import UEADataset
 
-__all__ = ['BaseDataset', 'TimeSeriesForecastingDataset']
+__all__ = ['BaseDataset', 'TimeSeriesForecastingDataset',
+           'TimeSeriesClassificationDataset', 'UEADataset']

basicts/data/base_dataset.py

@@ -8,7 +8,7 @@
 @dataclass
 class BaseDataset(Dataset):
     """
-    An abstract base class for creating datasets for time series forecasting in PyTorch.
+    An abstract base class for creating datasets for time series analysis in PyTorch.
 
     This class provides a structured template for defining custom datasets by specifying methods
     to load data and descriptions, and to access individual samples. It is designed to be subclassed
@@ -19,18 +19,11 @@ class BaseDataset(Dataset):
         train_val_test_ratio (List[float]): Ratios for splitting the dataset into training, validation,
             and testing sets respectively. Each value in the list should sum to 1.0.
         mode (str): Operational mode of the dataset. Valid values are "train", "valid", or "test".
-        input_len (int): The length of the input sequence, i.e., the number of historical data points used.
-        output_len (int): The length of the output sequence, i.e., the number of future data points predicted.
-        overlap (bool): Flag to indicate whether the splits between training, validation, and testing can overlap. 
-            Defaults to False to enforce non-overlapping data in different sets, but can be set to True to allow overlap.
     """
 
     dataset_name: str
     train_val_test_ratio: List[float]
     mode: str
-    input_len: int
-    output_len: int
-    overlap: bool = False
 
     def _load_description(self) -> dict:
         """

basicts/data/simple_inference_dataset.py

@@ -36,8 +36,9 @@ def __init__(self, dataset_name:str, dataset: Union[str, list], input_len: int,
         """
         train_val_test_ratio: List[float] = []
         mode: str = 'inference'
-        overlap = False
-        super().__init__(dataset_name, train_val_test_ratio, mode, input_len, output_len, overlap)
+        super().__init__(dataset_name, train_val_test_ratio, mode)
+        self.input_len = input_len
+        self.output_len = output_len
         self.logger = logger
 
         self.description = {}