opt the tft model benchmark

Author: imu1984

Makefile

@@ -7,7 +7,7 @@ CHECK_DIRS := tfts examples tests
 style:  ## Run formatters and linters (black, isort, flake8, pre-commit)
 	black $(CHECK_DIRS)
 	isort $(CHECK_DIRS)
-	flake8 $(check_dirs)
+	flake8 $(CHECK_DIRS)
 	pre-commit run --all-files
 
 ## Run all unit tests

examples/README.md

@@ -13,6 +13,9 @@ Dive deeper with these notebooks:
 - [single step prediction](https://nbviewer.org/github/LongxingTan/Time-series-prediction/blob/master/examples/notebooks/single_step_weather_prediction.ipynb): A guided example on predicting the next time point in weather data.
 - [multi steps prediction](https://nbviewer.org/github/LongxingTan/Time-series-prediction/blob/master/examples/notebooks/multi_steps_sales_prediction.ipynb): Learn how to forecast multiple future time points in a sales dataset.
 
+## 📊 Benchmark
+- [Kaggle - Forecasting Sticker Sales](https://www.kaggle.com/competitions/playground-series-s5e1)
+
 
 ## 🏆 More examples
 Check out these advanced examples and competition-winning implementations:

examples/benchmarks/CMI_detect_sleep_states/README.md

@@ -0,0 +1,21 @@
+seed: 315
+
+data:
+  data_path: "data.csv"
+  target_column: "target"
+  freq: 'h'
+
+model:
+  name: bert
+  predict_sequence_length: 32
+  n_layers: 2
+  hidden_size: 128
+  n_features: 10
+  n_output: 1
+
+
+training:
+  batch_size: 128
+  epochs: 30
+  learning_rate: 0.001
+  loss: "MSE"

examples/benchmarks/CMI_detect_sleep_states/conf.yaml

@@ -0,0 +1,215 @@
+import warnings
+
+from joblib import Parallel, delayed
+import numpy as np
+from omegaconf import OmegaConf
+import pandas as pd
+import requests
+from sklearn.preprocessing import StandardScaler
+from tensorflow.keras.utils import Sequence
+
+warnings.filterwarnings("ignore")
+
+
+# https://www.kaggle.com/code/cdeotte/transformer-starter-lb-0-052
+class TimeSeriesProcessor:
+    def __init__(self, use_internet=True, path="./"):
+        self.use_internet = use_internet
+        self.path = path
+        self.scales = {}
+        self.gdp_data = None
+
+    def fetch_gdp(self, df):
+        """Unified GDP fetching logic."""
+        alpha3_map = {
+            "Canada": "CAN",
+            "Finland": "FIN",
+            "Italy": "ITA",
+            "Kenya": "KEN",
+            "Norway": "NOR",
+            "Singapore": "SGP",
+        }
+        df["alpha3"] = df["country"].map(alpha3_map)
+        df["year"] = df["date"].dt.year
+        years = df["year"].unique()
+
+        if self.use_internet:
+            gdp_dict = {}
+            for country, a3 in alpha3_map.items():
+                try:
+                    url = f"https://api.worldbank.org/v2/country/{a3}/indicator/NY.GDP.PCAP.CD?date={min(years)}:{max(years)}&format=json"  # noqa: E501,E231
+                    res = requests.get(url).json()[1]
+                    for entry in res:
+                        gdp_dict[(a3, int(entry["date"]))] = entry["value"]
+                except Exception as e:
+                    print(f"Error fetching GDP for {a3}: {e}")
+            self.gdp_data = gdp_dict
+        else:
+            # Assume local file exists
+            gdp_df = pd.read_csv(f"{self.path}gdp.csv").set_index("alpha3")
+            self.gdp_data = gdp_df.to_dict()
+
+        return df
+
+    def process_features(self, df, is_train=True):
+        """Calculates GDP ratios and store-based normalization."""
+        df = df.copy()
+        df["date"] = pd.to_datetime(df["date"])
+
+        if self.gdp_data is None:
+            df = self.fetch_gdp(df)
+
+        df["GDP"] = df.apply(lambda x: self.gdp_data.get((x["alpha3"], x["year"]), 1.0), axis=1)
+
+        # 1. GDP Normalization
+        df["scaled_target"] = df["num_sold"] / df["GDP"]
+
+        # 2. Store Ratio (calculate during train, apply during test)
+        if is_train:
+            self.store_ratios = df.groupby("store")["scaled_target"].mean().to_dict()
+
+        df["scaled_target"] /= df["store"].map(self.store_ratios)
+
+        # 3. Kenya Fudge Factor
+        df.loc[df["country"] == "Kenya", "scaled_target"] *= 1.15
+
+        return df
+
+    def dataframe_to_tensor(self, df):
+        """
+        Pivots the dataframe into a 3D tensor: (Products, Time, Series)
+        Series = Country + Store combinations.
+        """
+        # Create a unique key for each Country/Store combination
+        df["series_key"] = df["country"] + "_" + df["store"]
+
+        products = sorted(df["product"].unique())
+        series_keys = sorted(df["series_key"].unique())
+
+        tensor_list = []
+        for prod in products:
+            # Efficient pivoting instead of nested loops
+            subset = df[df["product"] == prod].pivot(index="date", columns="series_key", values="scaled_target")
+
+            # Save scaling params per product
+            if prod not in self.scales:
+                self.scales[prod] = {"mean": subset.values.mean(), "std": subset.values.std()}
+
+            # Standard Scale
+            scaled_val = (subset.values - self.scales[prod]["mean"]) / self.scales[prod]["std"]
+            tensor_list.append(scaled_val)
+
+        return np.stack(tensor_list), products, series_keys
+
+    def inverse_transform(self, pred, product_name, country, store, date):
+        """Reverses all transformations to get the original num_sold scale."""
+        # 1. Reverse Standard Scale
+        val = (pred * self.scales[product_name]["std"]) + self.scales[product_name]["mean"]
+
+        # 2. Reverse Kenya Factor
+        if country == "Kenya":
+            val /= 1.15
+
+        # 3. Reverse Store Ratio
+        val *= self.store_ratios[store]
+
+        # 4. Reverse GDP
+        year = pd.to_datetime(date).year
+        # Note: You'd need a helper to get alpha3 from country
+        alpha3 = {
+            "Canada": "CAN",
+            "Finland": "FIN",
+            "Italy": "ITA",
+            "Kenya": "KEN",
+            "Norway": "NOR",
+            "Singapore": "SGP",
+        }[country]
+        val *= self.gdp_data.get((alpha3, year), 1.0)
+
+        return val
+
+
+class TimeSeriesDataset(Sequence):
+    def __init__(
+        self,
+        data,
+        mode="train",  # "train" or "test"
+        product_idx=0,
+        train_sequence_length=1440,
+        predict_sequence_length=32,
+        batch_size=32,
+    ):
+        self.data = data[product_idx]  # Shape: (Time, Series)
+        self.mode = mode
+        self.product_idx = product_idx
+        self.train_sequence_length = train_sequence_length
+        self.predict_sequence_length = predict_sequence_length
+        self.batch_size = batch_size
+
+        nans = np.isnan(self.data).astype("float32")
+        self.combined_data = np.stack([np.nan_to_num(self.data), nans], axis=-1)
+
+    def __len__(self):
+        return int(np.ceil(self.data.shape[1] / self.batch_size))
+
+    def __getitem__(self, idx):
+        if self.mode == "train":
+            return self._get_train_batch()
+        else:
+            return self._get_test_batch(idx)
+
+    def _get_train_batch(self):
+        X = np.zeros((self.batch_size, self.train_sequence_length, 2), dtype="float32")
+        y = np.zeros((self.batch_size, self.predict_sequence_length), dtype="float32")
+
+        for i in range(self.batch_size):
+            series_idx = np.random.randint(0, self.data.shape[1])
+            start = np.random.randint(0, self.data.shape[0] - self.train_sequence_length - self.predict_sequence_length)
+
+            X[i] = self.combined_data[start : start + self.train_sequence_length, series_idx, :]
+            y[i] = self.combined_data[
+                start + self.train_sequence_length : start + self.train_sequence_length + self.predict_sequence_length,
+                series_idx,
+                0,
+            ]
+        return X, y
+
+    def _get_test_batch(self, idx):
+        """Returns the LAST train_len for each category for prediction."""
+        start_series = idx * self.batch_size
+        end_series = min((idx + 1) * self.batch_size, self.data.shape[1])
+        actual_bs = end_series - start_series
+
+        X = np.zeros((actual_bs, self.train_sequence_length, 2), dtype="float32")
+
+        for i, s_idx in enumerate(range(start_series, end_series)):
+            # Always take the very tail of the data
+            X[i] = self.combined_data[-self.train_sequence_length :, s_idx, :]
+
+        return X
+
+
+if __name__ == "__main__":
+    # 1. Process Data
+    processor = TimeSeriesProcessor(use_internet=True)
+    df_train = pd.read_csv("/kaggle/input/playground-series-s5e1/train.csv")
+    df_processed = processor.process_features(df_train, is_train=True)
+    tensor, product_names, series_names = processor.dataframe_to_tensor(df_processed)
+
+    # 2. Create Train Dataset for Product 0
+    train_gen = TimeSeriesDataset(tensor, mode="train", product_idx=0)
+
+    # 3. Create Test Dataset (the last window for all series in Product 0)
+    test_gen = TimeSeriesDataset(tensor, mode="test", product_idx=0)
+
+    # # 4. Predict
+    # predictions = model.predict(test_gen) # (Total Series, pred_len)
+
+    # # 5. Reverse Scaling for a specific prediction
+    # raw_pred = processor.inverse_transform(
+    #     pred=predictions[0, 0],
+    #     product_name=product_names[0],
+    #     country="Canada",
+    #     store="KaggleMart",
+    #     date="2026-01-01"
+    # )

examples/benchmarks/CMI_detect_sleep_states/dataset.py

@@ -0,0 +1,96 @@
+import argparse
+import math
+import random
+
+from dataset import DataReader, TrainDataset
+import numpy as np
+from omegaconf import OmegaConf
+import pandas as pd
+import tensorflow as tf
+
+from tfts import AutoConfig, AutoModel, Pipeline, set_seed
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="tfts forecasting")
+    parser.add_argument("--config_path", type=str, default="conf.yaml", help="Path to base config file")
+    parser.add_argument("--debug", type=bool, default=False, help="Enable debug mode")
+    parser.add_argument("--is_training", type=bool, default=True, help="Whether to train or predict")
+    parser.add_argument("--model_name", type=str, default=None, help="Model name, e.g., BERT, LSTM")
+    parser.add_argument("--batch_size", type=int, default=None, help="Batch size")
+    parser.add_argument("--epochs", type=int, default=None, help="Number of epochs")
+
+    args = parser.parse_args()
+    return args
+
+
+# def run_inference(product_idx):
+#     """Runs the recursive prediction for a specific product."""
+#     # Ensure history has the 2nd channel (NaN indicator)
+#     # history_tensor shape: (5, 2557, 18) -> Needs expansion to (1, LEN, 18, 2)
+#     data = np.expand_dims(self.history_tensor, axis=-1)
+#     nans = np.isnan(data).astype('float32')
+#     data = np.concatenate([data, nans], axis=-1)
+
+#     product_preds = np.zeros((18, self.PRED_LEN * self.STEPS))
+#     bad_rows = []
+
+#     for jj in range(18):
+#         # Get last window of training data for this series
+#         # Shape: (1, LEN, 2)
+#         current_window = data[product_idx:product_idx+1, -self.LEN:, jj, :].copy()
+
+#         if np.isnan(current_window[:, :, 0]).sum() == self.LEN:
+#             bad_rows.append(jj)
+#             continue
+
+#         series_predictions = []
+
+#         for step in range(self.STEPS):
+#             # Predict next 32 days
+#             # Input shape: (1, LEN, 2)
+#             p2 = self.model(np.nan_to_num(current_window))
+#             p2 = p2.numpy().reshape((1, self.PRED_LEN, 1))
+
+#             # Add dummy NaN indicator (0.0) to predictions for the next step
+#             p2_with_nan = np.concatenate([p2, np.zeros_like(p2)], axis=-1)
+#             series_predictions.append(p2_with_nan)
+
+#             # Update window: Slide window forward
+#             # Remove oldest 32, append newest 32
+#             current_window = np.concatenate([current_window[:, self.PRED_LEN:, :], p2_with_nan], axis=1)
+
+#         # Combine all steps and remove the NaN indicator channel
+#         product_preds[jj, :] = np.concatenate([z[:, :, 0] for z in series_predictions], axis=1).flatten()
+
+#     # Handle bad rows (series with no training data)
+#     if bad_rows:
+#         fill_val = np.nanmean(product_preds, axis=0)
+#         for r in bad_rows:
+#             product_preds[r, :] = fill_val
+
+#     return product_preds
+
+
+def main():
+    args = parse_args()
+    cfg = OmegaConf.load(args.config_path)
+
+    set_seed(cfg.seed)
+
+    data_reader = DataReader()
+    train_df = data_reader.load_data("/kaggle/input/playground-series-s5e1/train.csv")
+    train_df = data_reader.add_features(train_df)
+    data_tensor = data_reader.reshape_to_tensor(train_df)
+
+    train_dataset = TrainDataset(
+        data=data_tensor, product_idx=0, batch_size=64, train_sequence_length=1440, predict_sequence_length=32
+    )
+
+    forecaster = Pipeline(cfg)
+
+    forecaster.train(train_dataset=train_dataset)
+
+
+if __name__ == "__main__":
+    main()

examples/benchmarks/forecasting_sticker_sales/README.md

@@ -4,8 +4,35 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Financial stock prediction"
+    "# Financial stock prediction\n",
+    "- the data is from binance API\n"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "from tfts import AutoConfig, AutoModel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {