tabpfn-time-series 0.1.3__tar.gz → 1.0.0__tar.gz

{tabpfn_time_series-0.1.3 → tabpfn_time_series-1.0.0}/.github/workflows/pull_request.yml

@@ -27,7 +27,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: ["3.9", "3.10"]
+        python-version: ["3.10", "3.11", "3.12"]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
@@ -56,4 +56,4 @@ jobs:
         env:
           TABPFN_CLIENT_API_KEY: ${{ secrets.TABPFN_CLIENT_API_KEY }}
         run: |
-          python -m unittest discover -s tests -t tests
+          python -m unittest discover -s tests -t tests

{tabpfn_time_series-0.1.3 → tabpfn_time_series-1.0.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tabpfn_time_series
-Version: 0.1.3
-Summary: Zero-shot time series forecasting with TabPFN
+Version: 1.0.0
+Summary: Zero-shot time series forecasting with TabPFNv2
 Project-URL: Homepage, https://github.com/liam-sbhoo/tabpfn-time-series
 Project-URL: Bug Tracker, https://github.com/liam-sbhoo/tabpfn-time-series/issues
 Author-email: Liam Shi Bin Hoo <hoos@tf.uni-freiburg.de>
@@ -14,32 +14,39 @@ Requires-Dist: autogluon-timeseries>=1.2
 Requires-Dist: datasets>=3.3.2
 Requires-Dist: gluonts>=0.16.0
 Requires-Dist: pandas<2.2.0,>=2.1.2
-Requires-Dist: tabpfn-client>=0.1.1
-Requires-Dist: tabpfn>=2.0.0
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: tabpfn-client>=0.1.7
+Requires-Dist: tabpfn>=2.0.9
 Requires-Dist: tqdm
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: jupyter; extra == 'dev'
 Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: submitit>=1.5.2; extra == 'dev'
 Requires-Dist: twine; extra == 'dev'
+Requires-Dist: wandb>=0.19.8; extra == 'dev'
 Description-Content-Type: text/markdown
 
-# Zero-Shot Time Series Forecasting with TabPFN
+# TabPFN-TS
+
+> Zero-Shot Time Series Forecasting with TabPFNv2
 
 [![PyPI version](https://badge.fury.io/py/tabpfn-time-series.svg)](https://badge.fury.io/py/tabpfn-time-series)
 [![colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/liam-sbhoo/tabpfn-time-series/blob/main/demo.ipynb)
 [![Discord](https://img.shields.io/discord/1285598202732482621?color=7289da&label=Discord&logo=discord&logoColor=ffffff)](https://discord.com/channels/1285598202732482621/)
-[![arXiv](https://img.shields.io/badge/arXiv-2501.02945-<COLOR>.svg)](https://arxiv.org/abs/2501.02945)
+[![arXiv](https://img.shields.io/badge/arXiv-2501.02945-<COLOR>.svg)](https://arxiv.org/abs/2501.02945v3)
 
 ## 📌 News
+- **27-05-2025**: 📝 New **[paper](https://arxiv.org/abs/2501.02945v3)** version and **v1.0.0** release! Strong [GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval) results, new AutoSeasonalFeatures, improved CalendarFeatures.
 - **27-01-2025**: 🚀 Ranked _**1st**_ on [GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval) benchmark<sup>[1]</sup>!
-- **10-10-2024**: 🚀 TabPFN-TS [paper](https://arxiv.org/abs/2501.02945) accepted to NeurIPS 2024 [TRL](https://table-representation-learning.github.io/NeurIPS2024/) and [TSALM](https://neurips-time-series-workshop.github.io/) workshops!
+- **10-10-2024**: 🚀 TabPFN-TS [paper](https://arxiv.org/abs/2501.02945v2) accepted to NeurIPS 2024 [TRL](https://table-representation-learning.github.io/NeurIPS2024/) and [TSALM](https://neurips-time-series-workshop.github.io/) workshops!
 
 _[1] Last checked on: 10/03/2025_
 
 ## ✨ Introduction
-We demonstrate that the tabular foundation model **[TabPFN](https://github.com/PriorLabs/TabPFN)**, when paired with minimal featurization, can perform zero-shot time series forecasting. Its performance on point forecasting matches or even slightly outperforms state-of-the-art methods.
+We demonstrate that the tabular foundation model **[TabPFNv2](https://github.com/PriorLabs/TabPFN)**, combined with lightweight feature engineering, enables zero-shot time series forecasting for both point and probabilistic tasks. On the **[GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval)** benchmark, our method achieves performance on par with top-tier models across both evaluation metrics.
 
 ## 📖 How does it work?
 
@@ -49,27 +56,22 @@ Our work proposes to frame **univariate time series forecasting** as a **tabular
 
 Concretely, we:
 1. Transform a time series into a table
-2. Extract features from timestamp and add them to the table
-3. Perform regression on the table using TabPFN
+2. Extract features and add them to the table
+3. Perform regression on the table using TabPFNv2
 4. Use regression results as time series forecasting outputs
 
-For more details, please refer to our [paper](https://arxiv.org/abs/2501.02945) and our [poster](docs/tabpfn-ts-neurips-poster.pdf) (presented at NeurIPS 2024 TRL and TSALM workshops).
+For more details, please refer to our [paper](https://arxiv.org/abs/2501.02945v3).
+ <!-- and our [poster](docs/tabpfn-ts-neurips-poster.pdf) (presented at NeurIPS 2024 TRL and TSALM workshops). -->
 
 ## 👉 **Why gives us a try?**
 - **Zero-shot forecasting**: this method is extremely fast and requires no training, making it highly accessible for experimenting with your own problems.
 - **Point and probabilistic forecasting**: it provides accurate point forecasts as well as probabilistic forecasts.
 - **Support for exogenous variables**: if you have exogenous variables, this method can seemlessly incorporate them into the forecasting model.
 
-On top of that, thanks to **[tabpfn-client](https://github.com/automl/tabpfn-client)** from **[Prior Labs](https://priorlabs.ai)**, you won’t even need your own GPU to run fast inference with TabPFN. 😉 We have included `tabpfn-client` as the default engine in our implementation.
+On top of that, thanks to **[tabpfn-client](https://github.com/automl/tabpfn-client)** from **[Prior Labs](https://priorlabs.ai)**, you won’t even need your own GPU to run fast inference with TabPFNv2. 😉 We have included `tabpfn-client` as the default engine in our implementation.
 
 ## How to use it?
 
 [![colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/liam-sbhoo/tabpfn-time-series/blob/main/demo.ipynb)
 
 The demo should explain it all. 😉
-
-## 📊 GIFT-EVAL Benchmark
-
-We have submitted our results to the [GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval) benchmark. Stay tuned for results!
-
-For more details regarding the evaluation setup, please refer to [README.md](gift_eval/README.md).

{tabpfn_time_series-0.1.3 → tabpfn_time_series-1.0.0}/README.md

@@ -1,18 +1,21 @@
-# Zero-Shot Time Series Forecasting with TabPFN
+# TabPFN-TS
+
+> Zero-Shot Time Series Forecasting with TabPFNv2
 
 [![PyPI version](https://badge.fury.io/py/tabpfn-time-series.svg)](https://badge.fury.io/py/tabpfn-time-series)
 [![colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/liam-sbhoo/tabpfn-time-series/blob/main/demo.ipynb)
 [![Discord](https://img.shields.io/discord/1285598202732482621?color=7289da&label=Discord&logo=discord&logoColor=ffffff)](https://discord.com/channels/1285598202732482621/)
-[![arXiv](https://img.shields.io/badge/arXiv-2501.02945-<COLOR>.svg)](https://arxiv.org/abs/2501.02945)
+[![arXiv](https://img.shields.io/badge/arXiv-2501.02945-<COLOR>.svg)](https://arxiv.org/abs/2501.02945v3)
 
 ## 📌 News
+- **27-05-2025**: 📝 New **[paper](https://arxiv.org/abs/2501.02945v3)** version and **v1.0.0** release! Strong [GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval) results, new AutoSeasonalFeatures, improved CalendarFeatures.
 - **27-01-2025**: 🚀 Ranked _**1st**_ on [GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval) benchmark<sup>[1]</sup>!
-- **10-10-2024**: 🚀 TabPFN-TS [paper](https://arxiv.org/abs/2501.02945) accepted to NeurIPS 2024 [TRL](https://table-representation-learning.github.io/NeurIPS2024/) and [TSALM](https://neurips-time-series-workshop.github.io/) workshops!
+- **10-10-2024**: 🚀 TabPFN-TS [paper](https://arxiv.org/abs/2501.02945v2) accepted to NeurIPS 2024 [TRL](https://table-representation-learning.github.io/NeurIPS2024/) and [TSALM](https://neurips-time-series-workshop.github.io/) workshops!
 
 _[1] Last checked on: 10/03/2025_
 
 ## ✨ Introduction
-We demonstrate that the tabular foundation model **[TabPFN](https://github.com/PriorLabs/TabPFN)**, when paired with minimal featurization, can perform zero-shot time series forecasting. Its performance on point forecasting matches or even slightly outperforms state-of-the-art methods.
+We demonstrate that the tabular foundation model **[TabPFNv2](https://github.com/PriorLabs/TabPFN)**, combined with lightweight feature engineering, enables zero-shot time series forecasting for both point and probabilistic tasks. On the **[GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval)** benchmark, our method achieves performance on par with top-tier models across both evaluation metrics.
 
 ## 📖 How does it work?
 
@@ -22,27 +25,22 @@ Our work proposes to frame **univariate time series forecasting** as a **tabular
 
 Concretely, we:
 1. Transform a time series into a table
-2. Extract features from timestamp and add them to the table
-3. Perform regression on the table using TabPFN
+2. Extract features and add them to the table
+3. Perform regression on the table using TabPFNv2
 4. Use regression results as time series forecasting outputs
 
-For more details, please refer to our [paper](https://arxiv.org/abs/2501.02945) and our [poster](docs/tabpfn-ts-neurips-poster.pdf) (presented at NeurIPS 2024 TRL and TSALM workshops).
+For more details, please refer to our [paper](https://arxiv.org/abs/2501.02945v3).
+ <!-- and our [poster](docs/tabpfn-ts-neurips-poster.pdf) (presented at NeurIPS 2024 TRL and TSALM workshops). -->
 
 ## 👉 **Why gives us a try?**
 - **Zero-shot forecasting**: this method is extremely fast and requires no training, making it highly accessible for experimenting with your own problems.
 - **Point and probabilistic forecasting**: it provides accurate point forecasts as well as probabilistic forecasts.
 - **Support for exogenous variables**: if you have exogenous variables, this method can seemlessly incorporate them into the forecasting model.
 
-On top of that, thanks to **[tabpfn-client](https://github.com/automl/tabpfn-client)** from **[Prior Labs](https://priorlabs.ai)**, you won’t even need your own GPU to run fast inference with TabPFN. 😉 We have included `tabpfn-client` as the default engine in our implementation.
+On top of that, thanks to **[tabpfn-client](https://github.com/automl/tabpfn-client)** from **[Prior Labs](https://priorlabs.ai)**, you won’t even need your own GPU to run fast inference with TabPFNv2. 😉 We have included `tabpfn-client` as the default engine in our implementation.
 
 ## How to use it?
 
 [![colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/liam-sbhoo/tabpfn-time-series/blob/main/demo.ipynb)
 
 The demo should explain it all. 😉
-
-## 📊 GIFT-EVAL Benchmark
-
-We have submitted our results to the [GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval) benchmark. Stay tuned for results!
-
-For more details regarding the evaluation setup, please refer to [README.md](gift_eval/README.md).

{tabpfn_time_series-0.1.3 → tabpfn_time_series-1.0.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tabpfn_time_series"
-version = "0.1.3"
+version = "1.0.0"
 authors = [
   { name="Liam Shi Bin Hoo", email="hoos@tf.uni-freiburg.de" },
 ]
-description = "Zero-shot time series forecasting with TabPFN"
+description = "Zero-shot time series forecasting with TabPFNv2"
 readme = "README.md"
 requires-python = ">=3.10"
 classifiers = [

{tabpfn_time_series-0.1.3 → tabpfn_time_series-1.0.0}/requirements-dev.txt

@@ -1,5 +1,7 @@
 # for development
 jupyter
+wandb>=0.19.8
+submitit>=1.5.2
 ruff
 pre-commit
 twine

tabpfn_time_series-1.0.0/requirements.txt

@@ -0,0 +1,11 @@
+tqdm
+pandas>=2.1.2, <2.2.0
+gluonts>=0.16.0
+autogluon.timeseries>=1.2
+tabpfn-client>=0.1.7
+tabpfn>=2.0.9
+datasets>=3.3.2
+python-dotenv>=1.1.0
+
+# for python 3.12
+pyyaml>=6.0.1

{tabpfn_time_series-0.1.3 → tabpfn_time_series-1.0.0}/tabpfn_time_series/__init__.py

@@ -1,11 +1,10 @@
-from .feature import DefaultFeatures, FeatureTransformer
+from .features import FeatureTransformer
 from .predictor import TabPFNTimeSeriesPredictor, TabPFNMode
 from .defaults import TABPFN_TS_DEFAULT_QUANTILE_CONFIG
 
 __version__ = "0.1.0"
 
 __all__ = [
-    "DefaultFeatures",
     "FeatureTransformer",
     "TabPFNTimeSeriesPredictor",
     "TabPFNMode",

tabpfn_time_series-1.0.0/tabpfn_time_series/features/__init__.py

@@ -0,0 +1,17 @@
+from .basic_features import (
+    RunningIndexFeature,
+    CalendarFeature,
+    AdditionalCalendarFeature,
+    PeriodicSinCosineFeature,
+)
+from .auto_features import AutoSeasonalFeature
+from .feature_transformer import FeatureTransformer
+
+__all__ = [
+    "RunningIndexFeature",
+    "CalendarFeature",
+    "AdditionalCalendarFeature",
+    "AutoSeasonalFeature",
+    "PeriodicSinCosineFeature",
+    "FeatureTransformer",
+]

tabpfn_time_series-1.0.0/tabpfn_time_series/features/auto_features.py

@@ -0,0 +1,307 @@
+import numpy as np
+import pandas as pd
+from typing import List, Optional, Tuple, Literal
+
+import logging
+
+from scipy import fft
+from scipy.signal import find_peaks
+from statsmodels.tsa.stattools import acf
+
+from tabpfn_time_series.features.feature_generator_base import (
+    FeatureGenerator,
+)
+from tabpfn_time_series.features.basic_features import (
+    PeriodicSinCosineFeature,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class AutoSeasonalFeature(FeatureGenerator):
+    class Config:
+        max_top_k: int = 5
+        do_detrend: bool = True
+        detrend_type: Literal["first_diff", "loess", "linear", "constant"] = "linear"
+        use_peaks_only: bool = True
+        apply_hann_window: bool = True
+        zero_padding_factor: int = 2
+        round_to_closest_integer: bool = True
+        validate_with_acf: bool = False
+        sampling_interval: float = 1.0
+        magnitude_threshold: Optional[float] = 0.05
+        relative_threshold: bool = True
+        exclude_zero: bool = True
+
+    def __init__(self, config: Optional[dict] = None):
+        # Create default config from Config class
+        default_config = {
+            k: v for k, v in vars(self.Config).items() if not k.startswith("__")
+        }
+
+        # Initialize config with defaults
+        self.config = default_config.copy()
+
+        # Update with user-provided config if any
+        if config is not None:
+            self.config.update(config)
+
+        # Validate config parameters
+        self._validate_config()
+
+        logger.debug(f"Initialized AutoSeasonalFeature with config: {self.config}")
+
+    def _validate_config(self):
+        """Validate configuration parameters"""
+        if self.config["max_top_k"] < 1:
+            logger.warning("max_top_k must be at least 1, setting to 1")
+            self.config["max_top_k"] = 1
+
+        if self.config["zero_padding_factor"] < 1:
+            logger.warning("zero_padding_factor must be at least 1, setting to 1")
+            self.config["zero_padding_factor"] = 1
+
+        if self.config["detrend_type"] not in [
+            "first_diff",
+            "loess",
+            "linear",
+            "constant",
+        ]:
+            logger.warning(
+                f"Invalid detrend_type: {self.config['detrend_type']}, using 'linear'"
+            )
+            self.config["detrend_type"] = "linear"
+
+    def generate(self, df: pd.DataFrame) -> pd.DataFrame:
+        df = df.copy()
+
+        # Detect seasonal periods from target data
+        detected_periods_and_magnitudes = self.find_seasonal_periods(
+            df.target, **self.config
+        )
+        logger.debug(
+            f"Found {len(detected_periods_and_magnitudes)} seasonal periods: {detected_periods_and_magnitudes}"
+        )
+
+        # Extract just the periods (without magnitudes)
+        periods = [period for period, _ in detected_periods_and_magnitudes]
+
+        # Generate features for detected periods using PeriodicSinCosineFeature
+        if periods:
+            feature_generator = PeriodicSinCosineFeature(periods=periods)
+            df = feature_generator.generate(df)
+
+        # Standardize column names for consistency across time series
+        renamed_columns = {}
+        for i, period in enumerate(periods):
+            renamed_columns[f"sin_{period}"] = f"sin_#{i}"
+            renamed_columns[f"cos_{period}"] = f"cos_#{i}"
+
+        df = df.rename(columns=renamed_columns)
+
+        # Add placeholder zero columns for missing periods up to max_top_k
+        for i in range(len(periods), self.config["max_top_k"]):
+            df[f"sin_#{i}"] = 0.0
+            df[f"cos_#{i}"] = 0.0
+
+        return df
+
+    @staticmethod
+    def find_seasonal_periods(
+        target_values: pd.Series,
+        max_top_k: int = 10,
+        do_detrend: bool = True,
+        detrend_type: Literal[
+            "first_diff", "loess", "linear", "constant"
+        ] = "first_diff",
+        use_peaks_only: bool = True,
+        apply_hann_window: bool = True,
+        zero_padding_factor: int = 2,
+        round_to_closest_integer: bool = True,
+        validate_with_acf: bool = False,
+        sampling_interval: float = 1.0,
+        magnitude_threshold: Optional[
+            float
+        ] = 0.05,  # Default relative threshold (5% of max)
+        relative_threshold: bool = True,  # Interpret threshold as a fraction of max FFT magnitude
+        exclude_zero: bool = False,
+    ) -> List[Tuple[float, float]]:
+        """
+        Identify dominant seasonal periods in a time series using FFT.
+
+        Parameters:
+        - target_values: pd.Series
+            Input time series data.
+        - max_top_k: int
+            Maximum number of dominant periods to return.
+        - do_detrend: bool
+            If True, remove the linear trend from the signal.
+        - use_peaks_only: bool
+            If True, consider only local peaks in the FFT magnitude spectrum.
+        - apply_hann_window: bool
+            If True, apply a Hann window to reduce spectral leakage.
+        - zero_padding_factor: int
+            Factor by which to zero-pad the signal for finer frequency resolution.
+        - round_to_closest_integer: bool
+            If True, round the detected periods to the nearest integer.
+        - validate_with_acf: bool
+            If True, validate detected periods against the autocorrelation function.
+        - sampling_interval: float
+            Time interval between consecutive samples.
+        - magnitude_threshold: Optional[float]
+            Threshold to filter out less significant frequency components.
+            Default is 0.05, interpreted as 5% of the maximum FFT magnitude if relative_threshold is True.
+        - relative_threshold: bool
+            If True, the `magnitude_threshold` is interpreted as a fraction of the maximum FFT magnitude.
+            Otherwise, it is treated as an absolute threshold value.
+        - exclude_zero: bool
+            If True, exclude periods of 0 from the results.
+
+        Returns:
+        - List[Tuple[float, float]]:
+            A list of (period, magnitude) tuples, sorted in descending order by magnitude.
+        """
+        # Convert the Pandas Series to a NumPy array
+        values = np.array(target_values, dtype=float)
+
+        # Quick hack to ignore the test_X
+        #   (Assuming train_X target is not NaN, and test_X target is NaN)
+        #   Dropping all the NaN values
+        values = values[~np.isnan(values)]
+
+        N_original = len(values)
+
+        # Detrend the signal using a linear detrend method if requested
+        if do_detrend:
+            values = detrend(values, detrend_type)
+
+        # Apply a Hann window to reduce spectral leakage
+        if apply_hann_window:
+            window = np.hanning(N_original)
+            values = values * window
+
+        # Zero-pad the signal for improved frequency resolution
+        if zero_padding_factor > 1:
+            padded_length = int(N_original * zero_padding_factor)
+            padded_values = np.zeros(padded_length)
+            padded_values[:N_original] = values
+            values = padded_values
+            N = padded_length
+        else:
+            N = N_original
+
+        # Compute the FFT (using rfft) and obtain frequency bins
+        fft_values = fft.rfft(values)
+        fft_magnitudes = np.abs(fft_values)
+        freqs = np.fft.rfftfreq(N, d=sampling_interval)
+
+        # Exclude the DC component (0 Hz) to avoid bias from the signal's mean
+        fft_magnitudes[0] = 0.0
+
+        # Determine the threshold (absolute value)
+        if magnitude_threshold is not None and relative_threshold:
+            threshold_value = magnitude_threshold * np.max(fft_magnitudes)
+        else:
+            threshold_value = magnitude_threshold
+
+        # Identify dominant frequencies
+        if use_peaks_only:
+            if threshold_value is not None:
+                peak_indices, _ = find_peaks(fft_magnitudes, height=threshold_value)
+            else:
+                peak_indices, _ = find_peaks(fft_magnitudes)
+            if len(peak_indices) == 0:
+                # Fallback to considering all frequency bins if no peaks are found
+                peak_indices = np.arange(len(fft_magnitudes))
+            # Sort the peak indices by magnitude in descending order
+            sorted_peak_indices = peak_indices[
+                np.argsort(fft_magnitudes[peak_indices])[::-1]
+            ]
+            top_indices = sorted_peak_indices[:max_top_k]
+        else:
+            sorted_indices = np.argsort(fft_magnitudes)[::-1]
+            if threshold_value is not None:
+                sorted_indices = [
+                    i for i in sorted_indices if fft_magnitudes[i] >= threshold_value
+                ]
+            top_indices = sorted_indices[:max_top_k]
+
+        # Convert frequencies to periods (avoiding division by zero)
+        periods = np.zeros_like(freqs)
+        non_zero = freqs > 0
+        periods[non_zero] = 1.0 / freqs[non_zero]
+        top_periods = periods[top_indices]
+
+        logger.debug(f"Top periods: {top_periods}")
+
+        # Optionally round the periods to the nearest integer
+        if round_to_closest_integer:
+            top_periods = np.round(top_periods)
+
+        # Filter out zero periods if requested
+        if exclude_zero:
+            non_zero_mask = top_periods != 0
+            top_periods = top_periods[non_zero_mask]
+            top_indices = top_indices[non_zero_mask]
+
+        # Keep unique periods only
+        if len(top_periods) > 0:
+            unique_period_indices = np.unique(top_periods, return_index=True)[1]
+            top_periods = top_periods[unique_period_indices]
+            top_indices = top_indices[unique_period_indices]
+
+        # Pair each period with its corresponding magnitude
+        results = [
+            (top_periods[i], fft_magnitudes[top_indices[i]])
+            for i in range(len(top_indices))
+        ]
+
+        # Validate with ACF if requested and filter the results accordingly
+        if validate_with_acf:
+            # Compute ACF on the original (non-padded) detrended signal
+            acf_values = acf(
+                np.array(target_values, dtype=float)[:N_original],
+                nlags=N_original,
+                fft=True,
+            )
+            acf_peak_indices, _ = find_peaks(
+                acf_values, height=1.96 / np.sqrt(N_original)
+            )
+            validated_results = []
+            for period, mag in results:
+                period_int = int(round(period))
+                if period_int < len(acf_values) and any(
+                    abs(period_int - peak) <= 1 for peak in acf_peak_indices
+                ):
+                    validated_results.append((period, mag))
+            if validated_results:
+                results = validated_results
+
+        # Ensure the final results are sorted in descending order by magnitude
+        results.sort(key=lambda x: x[1], reverse=True)
+
+        return results
+
+
+def detrend(
+    x: np.ndarray, detrend_type: Literal["first_diff", "loess", "linear"]
+) -> np.ndarray:
+    if detrend_type == "first_diff":
+        return np.diff(x, prepend=x[0])
+
+    elif detrend_type == "loess":
+        from statsmodels.api import nonparametric
+
+        indices = np.arange(len(x))
+        lowess = nonparametric.lowess(x, indices, frac=0.1)
+        trend = lowess[:, 1]
+        return x - trend
+
+    elif detrend_type in ["linear", "constant"]:
+        from scipy.signal import detrend as scipy_detrend
+
+        return scipy_detrend(x, type=detrend_type)
+
+    else:
+        raise ValueError(f"Invalid detrend method: {detrend_type}")

tabpfn_time_series-1.0.0/tabpfn_time_series/features/basic_features.py

@@ -0,0 +1,88 @@
+import numpy as np
+import pandas as pd
+from typing import List, Dict, Optional
+
+import gluonts.time_feature
+
+from tabpfn_time_series.features.feature_generator_base import (
+    FeatureGenerator,
+)
+
+
+class RunningIndexFeature(FeatureGenerator):
+    def generate(self, df: pd.DataFrame) -> pd.DataFrame:
+        df = df.copy()
+        df["running_index"] = range(len(df))
+        return df
+
+
+class CalendarFeature(FeatureGenerator):
+    def __init__(
+        self,
+        components: Optional[List[str]] = None,
+        seasonal_features: Optional[Dict[str, List[float]]] = None,
+    ):
+        self.components = components or ["year"]
+        self.seasonal_features = seasonal_features or {
+            # (feature, natural seasonality)
+            "second_of_minute": [60],
+            "minute_of_hour": [60],
+            "hour_of_day": [24],
+            "day_of_week": [7],
+            "day_of_month": [30.5],
+            "day_of_year": [365],
+            "week_of_year": [52],
+            "month_of_year": [12],
+        }
+
+    def generate(self, df: pd.DataFrame) -> pd.DataFrame:
+        df = df.copy()
+        timestamps = df.index.get_level_values("timestamp")
+
+        # Add basic calendar components
+        for component in self.components:
+            df[component] = getattr(timestamps, component)
+
+        # Add seasonal features
+        for feature_name, periods in self.seasonal_features.items():
+            feature_func = getattr(gluonts.time_feature, f"{feature_name}_index")
+            feature = feature_func(timestamps).astype(np.int32)
+
+            if periods is not None:
+                for period in periods:
+                    period = period - 1  # Adjust for 0-based indexing
+                    df[f"{feature_name}_sin"] = np.sin(2 * np.pi * feature / period)
+                    df[f"{feature_name}_cos"] = np.cos(2 * np.pi * feature / period)
+            else:
+                df[feature_name] = feature
+
+        return df
+
+
+class AdditionalCalendarFeature(CalendarFeature):
+    def __init__(
+        self,
+        components: Optional[List[str]] = None,
+        additional_seasonal_features: Optional[Dict[str, List[float]]] = None,
+    ):
+        super().__init__(components=components)
+
+        self.seasonal_features = {
+            **additional_seasonal_features,
+            **self.seasonal_features,
+        }
+
+
+class PeriodicSinCosineFeature(FeatureGenerator):
+    def __init__(self, periods: List[float], name_suffix: str = None):
+        self.periods = periods
+        self.name_suffix = name_suffix
+
+    def generate(self, df: pd.DataFrame) -> pd.DataFrame:
+        df = df.copy()
+        for i, period in enumerate(self.periods):
+            name_suffix = f"{self.name_suffix}_{i}" if self.name_suffix else f"{period}"
+            df[f"sin_{name_suffix}"] = np.sin(2 * np.pi * np.arange(len(df)) / period)
+            df[f"cos_{name_suffix}"] = np.cos(2 * np.pi * np.arange(len(df)) / period)
+
+        return df

tabpfn_time_series-1.0.0/tabpfn_time_series/features/feature_generator_base.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+import pandas as pd
+
+
+class FeatureGenerator(ABC):
+    """Abstract base class for feature generators"""
+
+    @abstractmethod
+    def generate(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Generate features for the given dataframe"""
+        pass
+
+    def __call__(self, df: pd.DataFrame) -> pd.DataFrame:
+        return self.generate(df)
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}_{self.__dict__}"
+
+    def __repr__(self) -> str:
+        return self.__str__()