From 0b987a3d708b39e910e1bbc305cea6658a3c80df Mon Sep 17 00:00:00 2001
From: tina <jintina48@gmail.com>
Date: Mon, 9 Jun 2025 17:45:46 +0800
Subject: [PATCH 1/6] basic setar-tree module and tests

---
 aeon/forecasting/__init__.py         |   2 +
 aeon/forecasting/_setar.py           | 285 +++++++++++++++++++++++++++
 aeon/forecasting/tests/test_setar.py | 114 +++++++++++
 3 files changed, 401 insertions(+)
 create mode 100644 aeon/forecasting/_setar.py
 create mode 100644 aeon/forecasting/tests/test_setar.py

diff --git a/aeon/forecasting/__init__.py b/aeon/forecasting/__init__.py
index 7a331f69e6..36b2ebea97 100644
--- a/aeon/forecasting/__init__.py
+++ b/aeon/forecasting/__init__.py
@@ -5,9 +5,11 @@
     "BaseForecaster",
     "RegressionForecaster",
     "ETSForecaster",
+    "SetartreeForecaster",
 ]
 
 from aeon.forecasting._ets import ETSForecaster
 from aeon.forecasting._naive import NaiveForecaster
 from aeon.forecasting._regression import RegressionForecaster
+from aeon.forecasting._setar import SetartreeForecaster
 from aeon.forecasting.base import BaseForecaster
diff --git a/aeon/forecasting/_setar.py b/aeon/forecasting/_setar.py
new file mode 100644
index 0000000000..b80f32d597
--- /dev/null
+++ b/aeon/forecasting/_setar.py
@@ -0,0 +1,285 @@
+"""SETAR-Tree: A tree algorithm for global time series forecasting."""
+
+import numpy as np
+from scipy.stats import f
+from sklearn.linear_model import LinearRegression
+
+from aeon.forecasting.base import BaseForecaster
+
+__maintainer__ = ["TinaJin0228"]
+__all__ = ["SetartreeForecaster"]
+
+
+class SetartreeForecaster(BaseForecaster):
+    """
+    SETAR-Tree: A tree algorithm for global time series forecasting.
+
+    This implementation is based on the paper "SETAR-Tree: a novel and accurate
+    tree algorithm for global time series forecasting" by Godahewa, R., et al. (2023).
+
+    Parameters
+    ----------
+    lag : int, default=10
+        The number of past lags to use as features for forecasting.
+    horizon : int, default=1
+        The number of time steps ahead to forecast.
+    max_depth : int, default=10
+        The maximum depth of the tree.
+    stopping_criteria : {"lin_test", "error_imp", "both"}, default="both"
+        The criteria to use for stopping tree growth:
+        - "lin_test": Uses a statistical F-test for linearity.
+        - "error_imp": Uses a minimum error reduction threshold.
+        - "both": Uses both linearity test and error improvement.
+    significance : float, default=0.05
+        The initial significance level (alpha) for the linearity F-test.
+    significance_divider : int, default=2
+        The factor by which to divide the significance level at each tree depth.
+    error_threshold : float, default=0.03
+        The minimum percentage of error reduction required to make a split.
+    """
+
+    def __init__(
+        self,
+        lag: int = 10,
+        horizon: int = 1,
+        max_depth: int = 10,
+        stopping_criteria: str = "both",
+        significance: float = 0.05,
+        significance_divider: int = 2,
+        error_threshold: float = 0.03,
+    ):
+        super().__init__(horizon=horizon, axis=1)
+        self.lag = lag
+        self.max_depth = max_depth
+        self.stopping_criteria = stopping_criteria
+        self.significance = significance
+        self.significance_divider = significance_divider
+        self.error_threshold = error_threshold
+
+        # Attributes to be fitted
+        self.tree_ = {}
+        self.leaf_models_ = {}
+
+        # for in-sample prediction when y = None in predict()
+        self._last_window = None
+
+    def _create_input_matrix(self, y: np.ndarray):
+        """Create an embedded matrix from a time series."""
+        n_series, n_timepoints = y.shape
+
+        # We need at least lag + 1 points to create one sample
+        if n_timepoints < self.lag + 1:
+            return None, None
+
+        X_list, y_list = [], []
+        for i in range(n_series):
+            series = y[i, :]
+            for j in range(len(series) - self.lag):
+                X_list.append(series[j : j + self.lag])
+                y_list.append(series[j + self.lag])
+
+        # The paper uses a convention of Lags 1, 2, 3...
+        # we flip the columns to match the convention
+        return np.fliplr(np.array(X_list)), np.array(y_list)
+
+    def _fit_pr_model(self, X, y):
+        """Fit a Pooled Regression (linear) model."""
+        model = LinearRegression()
+        model.fit(X, y)
+        return model
+
+    def _calculate_sse(self, model, X, y):
+        """Calculate the Sum of Squared Errors (SSE)."""
+        if len(y) == 0:
+            return 0
+        predictions = model.predict(X)
+        return np.sum((y - predictions) ** 2)
+
+    def _find_optimal_split(self, X, y):
+        """Find the best lag and threshold for a split."""
+        # currently standard, brute-force grid search method
+        best_split = {"sse": float("inf")}
+        n_samples, n_features = X.shape
+
+        for lag_idx in range(n_features):
+            thresholds = np.unique(X[:, lag_idx])
+            for t in thresholds:
+                left_indices = X[:, lag_idx] < t
+                right_indices = X[:, lag_idx] >= t
+
+                if np.sum(left_indices) == 0 or np.sum(right_indices) == 0:
+                    continue
+
+                X_left, y_left = X[left_indices], y[left_indices]
+                X_right, y_right = X[right_indices], y[right_indices]
+
+                model_left = self._fit_pr_model(X_left, y_left)
+                model_right = self._fit_pr_model(X_right, y_right)
+
+                sse_left = self._calculate_sse(model_left, X_left, y_left)
+                sse_right = self._calculate_sse(model_right, X_right, y_right)
+                total_sse = sse_left + sse_right
+
+                if total_sse < best_split["sse"]:
+                    best_split = {
+                        "sse": total_sse,
+                        "lag_idx": lag_idx,
+                        "threshold": t,
+                        "left_indices": left_indices,
+                        "right_indices": right_indices,
+                    }
+        return best_split
+
+    def _check_linearity(self, parent_sse, child_sse, n_samples, current_alpha):
+        """Perform the F-test to check for remaining non-linearity."""
+        # Degrees of freedom for parent and child models
+        # df_parent = n_samples - self.lag - 1
+        df_child = n_samples - 2 * self.lag - 2
+
+        if df_child <= 0:
+            return False
+
+        f_stat = ((parent_sse - child_sse) / (self.lag + 1)) / (child_sse / df_child)
+        p_value = 1 - f.cdf(f_stat, self.lag + 1, df_child)
+
+        return p_value < current_alpha
+
+    def _check_error_improvement(self, parent_sse, child_sse):
+        """Check if the error reduction from splitting is sufficient."""
+        if parent_sse == 0:
+            return False
+        improvement = (parent_sse - child_sse) / parent_sse
+        return improvement >= self.error_threshold
+
+    def _fit(self, y, exog=None):
+        # store last `lag` for each series
+        self._last_window = y[:, -self.lag :].copy()
+
+        X, y_embedded = self._create_input_matrix(y)
+        if X is None:
+            # If not enough data, fit a single model on what's available
+            self.tree_ = {"is_leaf": True, "node_id": 0}
+            self.leaf_models_[0] = self._fit_pr_model(y[:, :-1], y[:, -1])
+            return self
+
+        current_alpha = self.significance
+
+        # Initialize the tree with a root node
+        self.tree_ = {0: {"X": X, "y": y_embedded, "is_leaf": False}}
+        node_queue = [0]
+        next_node_id = 1
+
+        for _depth in range(self.max_depth):
+            if not node_queue:
+                break
+
+            nodes_at_this_level = list(node_queue)
+            node_queue.clear()
+
+            for node_id in nodes_at_this_level:
+                node = self.tree_[node_id]
+
+                # Try to find the best split for the current node
+                best_split = self._find_optimal_split(node["X"], node["y"])
+
+                if best_split["sse"] == float("inf"):
+                    node["is_leaf"] = True
+                    continue
+
+                # --- Stopping Criteria ---
+                parent_model = self._fit_pr_model(node["X"], node["y"])
+                parent_sse = self._calculate_sse(parent_model, node["X"], node["y"])
+                child_sse = best_split["sse"]
+
+                is_good_split = False
+                if self.stopping_criteria == "lin_test":
+                    is_good_split = self._check_linearity(
+                        parent_sse, child_sse, len(node["y"]), current_alpha
+                    )
+                elif self.stopping_criteria == "error_imp":
+                    is_good_split = self._check_error_improvement(parent_sse, child_sse)
+                elif self.stopping_criteria == "both":
+                    is_good_split = self._check_linearity(
+                        parent_sse, child_sse, len(node["y"]), current_alpha
+                    ) and self._check_error_improvement(parent_sse, child_sse)
+
+                if is_good_split:
+                    node["split_info"] = {
+                        "lag_idx": best_split["lag_idx"],
+                        "threshold": best_split["threshold"],
+                    }
+
+                    # Create left child
+                    left_id = next_node_id
+                    self.tree_[left_id] = {
+                        "X": node["X"][best_split["left_indices"]],
+                        "y": node["y"][best_split["left_indices"]],
+                        "is_leaf": False,
+                    }
+                    node["left_child"] = left_id
+                    node_queue.append(left_id)
+                    next_node_id += 1
+
+                    # Create right child
+                    right_id = next_node_id
+                    self.tree_[right_id] = {
+                        "X": node["X"][best_split["right_indices"]],
+                        "y": node["y"][best_split["right_indices"]],
+                        "is_leaf": False,
+                    }
+                    node["right_child"] = right_id
+                    node_queue.append(right_id)
+                    next_node_id += 1
+                else:
+                    node["is_leaf"] = True
+
+            # Decrease alpha for the next level
+            current_alpha /= self.significance_divider
+
+        # Fit models for all leaf nodes
+        for node_id, node in self.tree_.items():
+            if node["is_leaf"] or node.get("left_child") is None:
+                self.leaf_models_[node_id] = self._fit_pr_model(node["X"], node["y"])
+                node["is_leaf"] = True
+
+        return self
+
+    def _predict(self, y=None, exog=None):
+        self._check_is_fitted()
+
+        # If y is not provided, we predict from the end of the training data
+        if y is None:
+            history = self._last_window
+        else:
+            # Ensure y is 2D
+            if y.ndim == 1:
+                y = y.reshape(1, -1)
+            # We take the last 'lag' points of y for the initial prediction
+            history = y[0, -self.lag :]
+
+        predictions = []
+
+        for _ in range(self.horizon):
+            # Find the leaf node for the current history
+            current_node_id = 0
+            while not self.tree_[current_node_id]["is_leaf"]:
+                node = self.tree_[current_node_id]
+                split_info = node["split_info"]
+
+                # Note: Lags are flipped to match the paper's L1, L2... convention
+                lag_val = np.flip(history)[split_info["lag_idx"]]
+
+                if lag_val < split_info["threshold"]:
+                    current_node_id = node["left_child"]
+                else:
+                    current_node_id = node["right_child"]
+
+            # Predict using the leaf's model
+            leaf_model = self.leaf_models_[current_node_id]
+            next_pred = leaf_model.predict(history.reshape(1, -1))[0]
+            predictions.append(next_pred)
+
+            # Update history for the next prediction
+            history = np.append(history[1:], next_pred)
+
+        return np.array(predictions[self.horizon - 1])
diff --git a/aeon/forecasting/tests/test_setar.py b/aeon/forecasting/tests/test_setar.py
new file mode 100644
index 0000000000..d5601a23ee
--- /dev/null
+++ b/aeon/forecasting/tests/test_setar.py
@@ -0,0 +1,114 @@
+"""Test the setar-tree forecaster."""
+
+import numpy as np
+import pytest
+from sklearn.linear_model import LinearRegression
+
+from aeon.forecasting._setar import SetartreeForecaster
+
+
+def test_create_input_matrix_too_short():
+    """Ensure that too-short series yields (None, None)."""
+    # lag=3 but only 3 points => cannot create any samples
+    model = SetartreeForecaster(lag=3)
+    X, y = model._create_input_matrix(np.array([[1, 2, 3]]))
+    assert X is None and y is None
+
+
+def test_create_input_matrix_correct_shapes():
+    """Verify correct shapes and flipped ordering for a valid input matrix."""
+    # use lag=2 on a single series of length 5 => 5-2=3 samples of length 2
+    model = SetartreeForecaster(lag=2)
+    y = np.array([[10, 20, 30, 40, 50]])
+    X, y_out = model._create_input_matrix(y)
+    assert X.shape == (3, 2)
+    assert y_out.shape == (3,)
+    # first row of X should be [20,10] (flipped)
+    np.testing.assert_array_equal(X[0], np.array([20, 10]))
+    assert y_out[0] == 30
+
+
+def test_fit_pr_model_and_calculate_sse():
+    """Check that fitting a linear model and computing SSE works on y=2x."""
+    model = SetartreeForecaster()
+    # create a perfect linear relationship y=2x
+    X = np.array([[1], [2], [3]])
+    y = np.array([2, 4, 6])
+    lr = model._fit_pr_model(X, y)
+    # Check that coefficient is close to 2
+    assert pytest.approx(lr.coef_[0], rel=1e-3) == 2.0
+    # perfect fit => zero SSE
+    sse = model._calculate_sse(lr, X, y)
+    assert pytest.approx(sse, abs=1e-6) == 0.0
+
+
+def test_calculate_sse_empty_y():
+    """Ensure SSE returns 0 when y is empty."""
+    model = SetartreeForecaster()
+    # should return 0 rather than crash
+    lr = LinearRegression()
+    sse = model._calculate_sse(lr, np.empty((0, 1)), np.array([]))
+    assert sse == 0
+
+
+def test_find_optimal_split_simple():
+    """Confirm optimal split finds zero SSE on y=x for a single feature."""
+    model = SetartreeForecaster()
+    # single feature, y=x so best split at threshold=3 or 2 gives zero SSE
+    X = np.array([[1], [2], [3], [4]])
+    y = np.array([1, 2, 3, 4])
+    best = model._find_optimal_split(X, y)
+    assert best["sse"] == pytest.approx(0.0)
+    assert best["lag_idx"] == 0
+    # threshold must be one of the unique values that yields two non-empty splits
+    assert best["threshold"] in {2, 3}
+
+
+def test_check_linearity_degrees_of_freedom():
+    """Check that linearity test returns False when df_child ≤ 0."""
+    # for df_child <= 0 should immediately return False
+    model = SetartreeForecaster(lag=5)
+    parent_sse = 100
+    child_sse = 80
+    n_samples = 10  # df_child = 10 - 2*5 -2 = -2
+    assert (
+        model._check_linearity(parent_sse, child_sse, n_samples, current_alpha=0.05)
+        is False
+    )
+
+
+def test_check_error_improvement():
+    """Verify error improvement logic against the threshold."""
+    model = SetartreeForecaster(error_threshold=0.10)
+    # improvement = (100-85)/100 = 0.15 >= 0.10
+    assert model._check_error_improvement(100, 85) is True
+    # improvement = (100-95)/100 = 0.05 < 0.10
+    assert model._check_error_improvement(100, 95) is False
+
+
+def test_fit_short_series_creates_single_leaf():
+    """Ensure a tiny series still yields at least one leaf model."""
+    # With lag=2 and series length=3, embedded matrix exists,
+    # but splitting may not happen
+    model = SetartreeForecaster(lag=2, max_depth=1, stopping_criteria="both")
+    y = np.array([[1, 2, 3]])
+    fitted = model._fit(y)
+    # tree_ must be a dict and should mark root as leaf if no split happened
+    assert isinstance(fitted.tree_, dict)
+    # either the root is a leaf or there is at least one leaf model
+    assert fitted.leaf_models_
+
+
+def test_predict_in_sample_basic():
+    """Verify in-sample prediction returns the next true value for minimal data."""
+    # use lag=3 so that a series of length 4 yields exactly one training sample
+    model = SetartreeForecaster(lag=3, horizon=1)
+    # series = [1,2,3,4] → X=[[1,2,3]] → y=[4]
+    y = np.array([[1, 2, 3, 4]])
+    model.fit(y)
+
+    pred = model._predict()  # in‐sample path
+    # should be a numpy scalar/0‐d array equal to the true next value 4
+    assert isinstance(pred, np.ndarray)
+    assert pred.shape == ()  # scalar array
+    assert pred.item() == 4

From 636713caf44175483f250233e139a1e09d11989a Mon Sep 17 00:00:00 2001
From: tina <jintina48@gmail.com>
Date: Sun, 15 Jun 2025 11:15:30 +0800
Subject: [PATCH 2/6] add setar.ipynb as a temp document of setar forecaster

---
 aeon/forecasting/_setar.py       |  18 +-
 examples/forecasting/setar.ipynb | 371 +++++++++++++++++++++++++++++++
 2 files changed, 384 insertions(+), 5 deletions(-)
 create mode 100644 examples/forecasting/setar.ipynb

diff --git a/aeon/forecasting/_setar.py b/aeon/forecasting/_setar.py
index b80f32d597..c76f54a354 100644
--- a/aeon/forecasting/_setar.py
+++ b/aeon/forecasting/_setar.py
@@ -38,6 +38,10 @@ class SetartreeForecaster(BaseForecaster):
         The minimum percentage of error reduction required to make a split.
     """
 
+    _tags = {
+        "capability:multivariate": True,
+    }
+
     def __init__(
         self,
         lag: int = 10,
@@ -78,7 +82,7 @@ def _create_input_matrix(self, y: np.ndarray):
                 X_list.append(series[j : j + self.lag])
                 y_list.append(series[j + self.lag])
 
-        # The paper uses a convention of Lags 1, 2, 3...
+        # The paper uses a convention of Lags 1, 2...
         # we flip the columns to match the convention
         return np.fliplr(np.array(X_list)), np.array(y_list)
 
@@ -97,7 +101,7 @@ def _calculate_sse(self, model, X, y):
 
     def _find_optimal_split(self, X, y):
         """Find the best lag and threshold for a split."""
-        # currently standard, brute-force grid search method
+        # currently brute-force grid search method
         best_split = {"sse": float("inf")}
         n_samples, n_features = X.shape
 
@@ -249,7 +253,7 @@ def _predict(self, y=None, exog=None):
 
         # If y is not provided, we predict from the end of the training data
         if y is None:
-            history = self._last_window
+            history = self._last_window.flatten()
         else:
             # Ensure y is 2D
             if y.ndim == 1:
@@ -266,7 +270,7 @@ def _predict(self, y=None, exog=None):
                 node = self.tree_[current_node_id]
                 split_info = node["split_info"]
 
-                # Note: Lags are flipped to match the paper's L1, L2... convention
+                # Lags are flipped to match the paper's L1, L2... convention
                 lag_val = np.flip(history)[split_info["lag_idx"]]
 
                 if lag_val < split_info["threshold"]:
@@ -282,4 +286,8 @@ def _predict(self, y=None, exog=None):
             # Update history for the next prediction
             history = np.append(history[1:], next_pred)
 
-        return np.array(predictions[self.horizon - 1])
+        # Now I believe predict horizen steps forward is more natural
+        # than predict just one step at the horizen position...
+        # direct / recursive?
+        # return np.array(predictions[self.horizon - 1])
+        return np.array(predictions)
diff --git a/examples/forecasting/setar.ipynb b/examples/forecasting/setar.ipynb
new file mode 100644
index 0000000000..2a6dbc5702
--- /dev/null
+++ b/examples/forecasting/setar.ipynb
@@ -0,0 +1,371 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "52acc461",
+   "metadata": {},
+   "source": [
+    "# Temporary Notebook for the SETAR-Tree Forecaster\n",
+    "\n",
+    "This notebook serves as a demonstration to the implementation of the **SETAR-Tree** and future **SETAR-Forest**, a novel algorithm for global time series forecasting introduced in the paper \"SETAR-Tree: a novel and accurate tree algorithm for global time series forecasting\" by Godahewa, R., et al..\n",
+    "\n",
+    "The purpose of this notebook is to illustrate the concepts in the research paper and the Python code. I will cover two main areas:\n",
+    "1.  **How the Code Implements the Algorithm**: A step-by-step breakdown of the key methods in the `SetartreeForecaster` class, with direct references to the paper's descriptions and formulas.\n",
+    "2.  **Simple Usage Examples**: Demonstrations of how to fit the model and make predictions on toy datasets. (future: real datasets)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ec3a830e",
+   "metadata": {},
+   "source": [
+    "## 1. Brief Introduction of the SETAR-Tree Algorithm\n",
+    "\n",
+    "The SETAR-Tree algorithm introduces a hierarchical time series forecasting model that is structured as a regression tree but trained globally across multiple series. It stands out from traditional tree-based methods through two key innovations derived from the time series analysis field: \n",
+    "\n",
+    "#### 1: Pooled Regression (PR) in Leaf Nodes\n",
+    "Instead of simply averaging the training values that fall into a leaf node, the SETAR-Tree fits a **Pooled Regression (PR)** model in each leaf. A PR model is a global linear autoregressive model, which allows each leaf to learn from the cross-series information present in the data that falls into that specific regime.\n",
+    "\n",
+    "####  2: Time-Series Specific Splitting and Stopping\n",
+    "The tree's growth is not determined by generic criteria. Instead, it uses methods from threshold modeling:\n",
+    "* **Splitting**: The algorithm finds the optimal past **lag** and **threshold** to partition the data, based on the concepts of Self Exciting Threshold Autoregressive (SETAR) models.\n",
+    "* **Stopping**: The tree's depth is controlled automatically by conducting a statistical **linearity test** and measuring the **error reduction percentage** at each potential split. This greatly reduces the need for manual hyperparameter tuning.\n",
+    "\n",
+    "This notebook will now show how these concepts are implemented in the `SetartreeForecaster` class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c4e120c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 2. Setup: The SetartreeForecaster Class and Imports\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "from aeon.forecasting import SetartreeForecaster"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bcdccae8",
+   "metadata": {},
+   "source": [
+    "## 3. The `fit` Process\n",
+    "\n",
+    "Let's break down the main steps of the fitting process and see how the code handles them.\n",
+    "\n",
+    "### Step 3.1: Prepare the Data (`_create_input_matrix`)\n",
+    "The first step is to convert the raw time series data into a feature matrix `X` (the lags) and a target vector `y` (the value to be predicted). When multiple time series are provided, they are \"pooled\" into a single, large training set. This is the foundation of a global model. \n",
+    "\n",
+    "Let's see this in action with two simple time series."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4309cc83",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- Pooled Feature Matrix (X) ---\n",
+      "[[12 10]\n",
+      " [15 12]\n",
+      " [11 15]\n",
+      " [55 50]\n",
+      " [48 55]\n",
+      " [51 48]]\n",
+      "\n",
+      "--- Pooled Target Vector (y) ---\n",
+      "[15 11  9 48 51 56]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create two simple time series\n",
+    "y1 = np.array([10, 12, 15, 11, 9])\n",
+    "y2 = np.array([50, 55, 48, 51, 56])\n",
+    "y_train_multi = np.vstack([y1, y2])\n",
+    "\n",
+    "# Instantiate the forecaster with a small lag\n",
+    "model = SetartreeForecaster(lag=2)\n",
+    "\n",
+    "# Use the method to create the input matrix\n",
+    "X, y_target = model._create_input_matrix(y_train_multi)\n",
+    "\n",
+    "print(\"--- Pooled Feature Matrix (X) ---\")\n",
+    "print(X)\n",
+    "print(\"\\n--- Pooled Target Vector (y) ---\")\n",
+    "print(y_target)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f068262",
+   "metadata": {},
+   "source": [
+    "### Step 3.2: Find the Best Split (`_find_optimal_split`)\n",
+    "\n",
+    "For any node in the tree, the algorithm must find the best way to split its data. It does this by using a grid-search approach to test every lag and every possible threshold, looking for the split that **minimizes the total Sum of Squared Errors (SSE)** at the child nodes.\n",
+    "\n",
+    "This implementation uses a brute-force grid search for simplicity. The paper also describes a more computationally efficient method for this step in Section 3.3.1. (which will be implemented later... )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "bc46f3b7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- Optimal Split Information ---\n",
+      "Best Lag to Split On (Index): 0\n",
+      "Best Threshold Value: 48\n",
+      "Resulting SSE from this split: 0.00\n"
+     ]
+    }
+   ],
+   "source": [
+    "# We can call the split-finding function directly on our pooled data\n",
+    "best_split = model._find_optimal_split(X, y_target)\n",
+    "\n",
+    "print(\"--- Optimal Split Information ---\")\n",
+    "print(f\"Best Lag to Split On (Index): {best_split['lag_idx']}\")\n",
+    "print(f\"Best Threshold Value: {best_split['threshold']}\")\n",
+    "print(f\"Resulting SSE from this split: {best_split['sse']:.2f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a5acffc6",
+   "metadata": {},
+   "source": [
+    "### Step 3.3: Decide Whether to Split (Stopping Criteria)\n",
+    "Once the best possible split is found, the algorithm decides if it's actually worthwhile. The paper outlines two main criteria that control the tree's growth, which this implementation provides via the `stopping_criteria` parameter.\n",
+    "\n",
+    "1.  **`_check_linearity`**: This function implements the statistical **linearity F-test** described in Section 3.3.2 of the paper. It checks if splitting the node provides a statistically significant improvement over a single linear model. The null hypothesis, H₀, is that there is no significant remaining non-linearity. The code calculates the F-statistic according to **Equation (13)** in the paper.\n",
+    "\n",
+    "2.  **`_check_error_improvement`**: This function checks if the split reduces the error by a meaningful amount, as defined by the `error_threshold` parameter, which is detailed in Section 3.3.3."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3529d276",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- For a Good Split ---\n",
+      "Is the split statistically significant? False\n",
+      "Does it meet the error threshold? True\n",
+      "\n",
+      "--- For a Bad Split ---\n",
+      "Is the split statistically significant? False\n",
+      "Does it meet the error threshold? False\n"
+     ]
+    }
+   ],
+   "source": [
+    "# --- Demonstration of the stopping criteria ---\n",
+    "\n",
+    "# Assume we have a parent node's error and a potential child node's error\n",
+    "parent_sse = 150.0\n",
+    "child_sse_good_split = 100.0  # A significant improvement\n",
+    "child_sse_bad_split = 148.0  # A marginal improvement\n",
+    "\n",
+    "# A \"good\" split that would likely pass the tests\n",
+    "passes_linearity_check = model._check_linearity(\n",
+    "    parent_sse, child_sse_good_split, n_samples=len(y_target), current_alpha=0.05\n",
+    ")\n",
+    "passes_improvement_check = model._check_error_improvement(\n",
+    "    parent_sse, child_sse_good_split\n",
+    ")\n",
+    "print(\"\\n--- For a Good Split ---\")\n",
+    "print(f\"Is the split statistically significant? {passes_linearity_check}\")\n",
+    "print(f\"Does it meet the error threshold? {passes_improvement_check}\")\n",
+    "\n",
+    "\n",
+    "# A \"bad\" split that would likely fail\n",
+    "passes_linearity_check_bad = model._check_linearity(\n",
+    "    parent_sse, child_sse_bad_split, n_samples=len(y_target), current_alpha=0.05\n",
+    ")\n",
+    "passes_improvement_check_bad = model._check_error_improvement(\n",
+    "    parent_sse, child_sse_bad_split\n",
+    ")\n",
+    "print(\"\\n--- For a Bad Split ---\")\n",
+    "print(f\"Is the split statistically significant? {passes_linearity_check_bad}\")\n",
+    "print(f\"Does it meet the error threshold? {passes_improvement_check_bad}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d80a910d",
+   "metadata": {},
+   "source": [
+    "## 4. Simple Examples of Usage\n",
+    "\n",
+    "Now let's show some example usage of the forecaster with the standard `fit` and `predict` methods. \n",
+    "\n",
+    "### Example 4.1: Forecasting a Single Series\n",
+    "\n",
+    "Here, we'll train the model on the first part of a sine wave and ask it to predict the next few values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "4def532a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Generate a sine wave as our data\n",
+    "time = np.arange(0, 50, 0.5)\n",
+    "y_single = np.sin(time)\n",
+    "\n",
+    "# Split into train and test\n",
+    "train_data = y_single[:-20].reshape(1, -1)\n",
+    "\n",
+    "# Fit the model\n",
+    "model_single = SetartreeForecaster(lag=10, horizon=20, max_depth=5)\n",
+    "model_single.fit(train_data)\n",
+    "\n",
+    "# Get predictions\n",
+    "# We can either predict from the end of the training data (y=None)\n",
+    "# or provide the training data again as context.\n",
+    "predictions = model_single.predict(y=None)\n",
+    "\n",
+    "# Plot the results\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.plot(time, y_single, label=\"Full True Series\", color=\"gray\")\n",
+    "plt.plot(time[:-20], train_data.flatten(), label=\"Train Data\", color=\"blue\")\n",
+    "plt.plot(time[-20:], predictions, label=\"Forecast\", color=\"red\", linestyle=\"--\")\n",
+    "plt.title(\"Single Series Forecasting Example\")\n",
+    "plt.legend()\n",
+    "plt.grid(True, alpha=0.3)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e51b4ed1",
+   "metadata": {},
+   "source": [
+    "### Example 4.2: Global Forecasting and Predicting an Unseen Series\n",
+    "\n",
+    "Now for the main use case: training a single \"global\" model on multiple series, and then using it to forecast a completely new series it has never seen before. This highlights the model's ability to generalize."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5b27b318",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Global model fitted on two series.\n",
+      "Generated predictions for the new, unseen series.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 1. Create Training Data (two related series)\n",
+    "time_multi = np.arange(0, 40, 1)\n",
+    "y_multi_1 = 2 * np.sin(time_multi * 0.5) + np.random.normal(0, 0.2, 40)\n",
+    "y_multi_2 = 2 * np.cos(time_multi * 0.5) + np.random.normal(0, 0.2, 40)\n",
+    "y_train_global = np.vstack([y_multi_1, y_multi_2])\n",
+    "\n",
+    "# 2. Fit the Global Model\n",
+    "global_model = SetartreeForecaster(lag=8, horizon=15, max_depth=4)\n",
+    "global_model.fit(y_train_global)\n",
+    "print(\"Global model fitted on two series.\")\n",
+    "\n",
+    "# 3. Create a New, Unseen Series\n",
+    "time_new = np.arange(20, 60, 1)  # Different time range\n",
+    "y_new_unseen = 2 * np.sin(time_new * 0.5 + 1.5) + np.random.normal(0, 0.2, 40)\n",
+    "history_for_pred = y_new_unseen[:-15].reshape(1, -1)\n",
+    "\n",
+    "# 4. Predict on the Unseen Series\n",
+    "new_predictions = global_model.predict(y=history_for_pred)\n",
+    "print(\"Generated predictions for the new, unseen series.\")\n",
+    "\n",
+    "# 5. Plot the results\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.plot(time_new, y_new_unseen, label=\"Unseen True Series\", color=\"gray\")\n",
+    "plt.plot(\n",
+    "    time_new[:-15],\n",
+    "    history_for_pred.flatten(),\n",
+    "    label=\"Unseen Series History\",\n",
+    "    color=\"green\",\n",
+    ")\n",
+    "plt.plot(\n",
+    "    time_new[-15:],\n",
+    "    new_predictions,\n",
+    "    label=\"Forecast for Unseen Series\",\n",
+    "    color=\"red\",\n",
+    "    linestyle=\"--\",\n",
+    ")\n",
+    "plt.title(\"Forecasting a New, Unseen Series with a Global Model\")\n",
+    "plt.legend()\n",
+    "plt.grid(True, alpha=0.3)\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "aeon-venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 711e63bc0c5451b07eb76fcc88cc8c2c65a908a2 Mon Sep 17 00:00:00 2001
From: tina <jintina48@gmail.com>
Date: Sun, 15 Jun 2025 17:50:03 +0800
Subject: [PATCH 3/6] separate SETAR forecaster (demo)

---
 aeon/forecasting/__init__.py                  |   2 +-
 aeon/forecasting/_setar.py                    | 349 ++++++------------
 aeon/forecasting/_setartree.py                | 293 +++++++++++++++
 .../{test_setar.py => test_setartree.py}      |   2 +-
 examples/forecasting/setar.ipynb              |   9 +-
 5 files changed, 405 insertions(+), 250 deletions(-)
 create mode 100644 aeon/forecasting/_setartree.py
 rename aeon/forecasting/tests/{test_setar.py => test_setartree.py} (98%)

diff --git a/aeon/forecasting/__init__.py b/aeon/forecasting/__init__.py
index 36b2ebea97..a327a7d438 100644
--- a/aeon/forecasting/__init__.py
+++ b/aeon/forecasting/__init__.py
@@ -11,5 +11,5 @@
 from aeon.forecasting._ets import ETSForecaster
 from aeon.forecasting._naive import NaiveForecaster
 from aeon.forecasting._regression import RegressionForecaster
-from aeon.forecasting._setar import SetartreeForecaster
+from aeon.forecasting._setartree import SetartreeForecaster
 from aeon.forecasting.base import BaseForecaster
diff --git a/aeon/forecasting/_setar.py b/aeon/forecasting/_setar.py
index c76f54a354..110d29f8ba 100644
--- a/aeon/forecasting/_setar.py
+++ b/aeon/forecasting/_setar.py
@@ -1,293 +1,154 @@
-"""SETAR-Tree: A tree algorithm for global time series forecasting."""
+"""SETAR: A classic univariate forecasting algorithm."""
 
 import numpy as np
-from scipy.stats import f
 from sklearn.linear_model import LinearRegression
 
 from aeon.forecasting.base import BaseForecaster
 
-__maintainer__ = ["TinaJin0228"]
-__all__ = ["SetartreeForecaster"]
 
-
-class SetartreeForecaster(BaseForecaster):
+class SetarForecaster(BaseForecaster):
     """
-    SETAR-Tree: A tree algorithm for global time series forecasting.
+    SETAR: A classic univariate forecasting algorithm.
+
+    SETAR (Self-Exciting Threshold Autoregressive) model is a time series
+    model that defines two or more regimes based on a particular lagged
+    value of the series itself, using a separate autoregressive model for
+    each regime.
+
+    This model works on a single time series. It finds an optimal lag and
+    a single threshold on that lag's value to switch between two different
+    linear autoregressive models.
 
-    This implementation is based on the paper "SETAR-Tree: a novel and accurate
-    tree algorithm for global time series forecasting" by Godahewa, R., et al. (2023).
+    This implementation is based on the logic from the `get_setar_forecasts`
+    function in the original paper's R code
+    (https://github.com/rakshitha123/SETAR_Trees).
 
     Parameters
     ----------
     lag : int, default=10
-        The number of past lags to use as features for forecasting.
-    horizon : int, default=1
-        The number of time steps ahead to forecast.
-    max_depth : int, default=10
-        The maximum depth of the tree.
-    stopping_criteria : {"lin_test", "error_imp", "both"}, default="both"
-        The criteria to use for stopping tree growth:
-        - "lin_test": Uses a statistical F-test for linearity.
-        - "error_imp": Uses a minimum error reduction threshold.
-        - "both": Uses both linearity test and error improvement.
-    significance : float, default=0.05
-        The initial significance level (alpha) for the linearity F-test.
-    significance_divider : int, default=2
-        The factor by which to divide the significance level at each tree depth.
-    error_threshold : float, default=0.03
-        The minimum percentage of error reduction required to make a split.
+        The maximum number of past lags to consider for both the AR models
+        and as the thresholding variable.
     """
 
-    _tags = {
-        "capability:multivariate": True,
-    }
-
-    def __init__(
-        self,
-        lag: int = 10,
-        horizon: int = 1,
-        max_depth: int = 10,
-        stopping_criteria: str = "both",
-        significance: float = 0.05,
-        significance_divider: int = 2,
-        error_threshold: float = 0.03,
-    ):
-        super().__init__(horizon=horizon, axis=1)
+    def __init__(self, lag: int = 10, horizon: int = 1):
+        super().__init__(horizon=horizon)
         self.lag = lag
-        self.max_depth = max_depth
-        self.stopping_criteria = stopping_criteria
-        self.significance = significance
-        self.significance_divider = significance_divider
-        self.error_threshold = error_threshold
-
-        # Attributes to be fitted
-        self.tree_ = {}
-        self.leaf_models_ = {}
-
-        # for in-sample prediction when y = None in predict()
+        self.model_ = None
         self._last_window = None
 
-    def _create_input_matrix(self, y: np.ndarray):
-        """Create an embedded matrix from a time series."""
-        n_series, n_timepoints = y.shape
-
-        # We need at least lag + 1 points to create one sample
-        if n_timepoints < self.lag + 1:
-            return None, None
-
+    def _create_input_matrix(self, y, lag_val):
+        """Create an embedded matrix for a specific lag."""
         X_list, y_list = [], []
-        for i in range(n_series):
-            series = y[i, :]
-            for j in range(len(series) - self.lag):
-                X_list.append(series[j : j + self.lag])
-                y_list.append(series[j + self.lag])
-
-        # The paper uses a convention of Lags 1, 2...
-        # we flip the columns to match the convention
+        for j in range(len(y) - lag_val):
+            X_list.append(y[j : j + lag_val])
+            y_list.append(y[j + lag_val])
+        # Columns are L_lag, ..., L1. We flip to get L1, ..., L_lag
         return np.fliplr(np.array(X_list)), np.array(y_list)
 
-    def _fit_pr_model(self, X, y):
-        """Fit a Pooled Regression (linear) model."""
-        model = LinearRegression()
-        model.fit(X, y)
-        return model
-
-    def _calculate_sse(self, model, X, y):
-        """Calculate the Sum of Squared Errors (SSE)."""
-        if len(y) == 0:
-            return 0
-        predictions = model.predict(X)
-        return np.sum((y - predictions) ** 2)
-
-    def _find_optimal_split(self, X, y):
-        """Find the best lag and threshold for a split."""
-        # currently brute-force grid search method
-        best_split = {"sse": float("inf")}
-        n_samples, n_features = X.shape
-
-        for lag_idx in range(n_features):
-            thresholds = np.unique(X[:, lag_idx])
-            for t in thresholds:
-                left_indices = X[:, lag_idx] < t
-                right_indices = X[:, lag_idx] >= t
-
-                if np.sum(left_indices) == 0 or np.sum(right_indices) == 0:
-                    continue
-
-                X_left, y_left = X[left_indices], y[left_indices]
-                X_right, y_right = X[right_indices], y[right_indices]
-
-                model_left = self._fit_pr_model(X_left, y_left)
-                model_right = self._fit_pr_model(X_right, y_right)
-
-                sse_left = self._calculate_sse(model_left, X_left, y_left)
-                sse_right = self._calculate_sse(model_right, X_right, y_right)
-                total_sse = sse_left + sse_right
-
-                if total_sse < best_split["sse"]:
-                    best_split = {
-                        "sse": total_sse,
-                        "lag_idx": lag_idx,
-                        "threshold": t,
-                        "left_indices": left_indices,
-                        "right_indices": right_indices,
-                    }
-        return best_split
-
-    def _check_linearity(self, parent_sse, child_sse, n_samples, current_alpha):
-        """Perform the F-test to check for remaining non-linearity."""
-        # Degrees of freedom for parent and child models
-        # df_parent = n_samples - self.lag - 1
-        df_child = n_samples - 2 * self.lag - 2
-
-        if df_child <= 0:
-            return False
-
-        f_stat = ((parent_sse - child_sse) / (self.lag + 1)) / (child_sse / df_child)
-        p_value = 1 - f.cdf(f_stat, self.lag + 1, df_child)
-
-        return p_value < current_alpha
-
-    def _check_error_improvement(self, parent_sse, child_sse):
-        """Check if the error reduction from splitting is sufficient."""
-        if parent_sse == 0:
-            return False
-        improvement = (parent_sse - child_sse) / parent_sse
-        return improvement >= self.error_threshold
-
     def _fit(self, y, exog=None):
-        # store last `lag` for each series
-        self._last_window = y[:, -self.lag :].copy()
-
-        X, y_embedded = self._create_input_matrix(y)
-        if X is None:
-            # If not enough data, fit a single model on what's available
-            self.tree_ = {"is_leaf": True, "node_id": 0}
-            self.leaf_models_[0] = self._fit_pr_model(y[:, :-1], y[:, -1])
-            return self
+        """Fit the SETAR model to a single time series."""
+        self._last_window = y[-self.lag :].copy()
+        best_overall_sse = float("inf")
+        best_model_params = None
 
-        current_alpha = self.significance
+        for _lag in range(self.lag, 0, -1):
+            if len(y) <= _lag:
+                continue
 
-        # Initialize the tree with a root node
-        self.tree_ = {0: {"X": X, "y": y_embedded, "is_leaf": False}}
-        node_queue = [0]
-        next_node_id = 1
+            X, y_target = self._create_input_matrix(y, _lag)
+            if X.shape[0] < 2 * (_lag + 1):  # Need enough samples to fit two models
+                continue
 
-        for _depth in range(self.max_depth):
-            if not node_queue:
-                break
+            # Find the best threshold for the current lag `_lag`
+            # A deliberate simplification here to take L1; to be implemented
+            threshold_lag_idx = 0  # L1
 
-            nodes_at_this_level = list(node_queue)
-            node_queue.clear()
+            best_threshold_sse = float("inf")
+            best_threshold_params = None
 
-            for node_id in nodes_at_this_level:
-                node = self.tree_[node_id]
+            threshold_values = np.unique(X[:, threshold_lag_idx])
+            for t in threshold_values:
+                left_indices = X[:, threshold_lag_idx] < t
+                right_indices = X[:, threshold_lag_idx] >= t
 
-                # Try to find the best split for the current node
-                best_split = self._find_optimal_split(node["X"], node["y"])
-
-                if best_split["sse"] == float("inf"):
-                    node["is_leaf"] = True
+                # Ensure both child nodes are non-empty
+                if np.sum(left_indices) == 0 or np.sum(right_indices) == 0:
                     continue
 
-                # --- Stopping Criteria ---
-                parent_model = self._fit_pr_model(node["X"], node["y"])
-                parent_sse = self._calculate_sse(parent_model, node["X"], node["y"])
-                child_sse = best_split["sse"]
-
-                is_good_split = False
-                if self.stopping_criteria == "lin_test":
-                    is_good_split = self._check_linearity(
-                        parent_sse, child_sse, len(node["y"]), current_alpha
-                    )
-                elif self.stopping_criteria == "error_imp":
-                    is_good_split = self._check_error_improvement(parent_sse, child_sse)
-                elif self.stopping_criteria == "both":
-                    is_good_split = self._check_linearity(
-                        parent_sse, child_sse, len(node["y"]), current_alpha
-                    ) and self._check_error_improvement(parent_sse, child_sse)
-
-                if is_good_split:
-                    node["split_info"] = {
-                        "lag_idx": best_split["lag_idx"],
-                        "threshold": best_split["threshold"],
-                    }
-
-                    # Create left child
-                    left_id = next_node_id
-                    self.tree_[left_id] = {
-                        "X": node["X"][best_split["left_indices"]],
-                        "y": node["y"][best_split["left_indices"]],
-                        "is_leaf": False,
-                    }
-                    node["left_child"] = left_id
-                    node_queue.append(left_id)
-                    next_node_id += 1
+                # Fit a linear model to each regime
+                model_left = LinearRegression().fit(
+                    X[left_indices], y_target[left_indices]
+                )
+                model_right = LinearRegression().fit(
+                    X[right_indices], y_target[right_indices]
+                )
+
+                sse_left = np.sum(
+                    (model_left.predict(X[left_indices]) - y_target[left_indices]) ** 2
+                )
+                sse_right = np.sum(
+                    (model_right.predict(X[right_indices]) - y_target[right_indices])
+                    ** 2
+                )
+                total_sse = sse_left + sse_right
 
-                    # Create right child
-                    right_id = next_node_id
-                    self.tree_[right_id] = {
-                        "X": node["X"][best_split["right_indices"]],
-                        "y": node["y"][best_split["right_indices"]],
-                        "is_leaf": False,
+                if total_sse < best_threshold_sse:
+                    best_threshold_sse = total_sse
+                    best_threshold_params = {
+                        "threshold": t,
+                        "model_left": model_left,
+                        "model_right": model_right,
                     }
-                    node["right_child"] = right_id
-                    node_queue.append(right_id)
-                    next_node_id += 1
-                else:
-                    node["is_leaf"] = True
-
-            # Decrease alpha for the next level
-            current_alpha /= self.significance_divider
 
-        # Fit models for all leaf nodes
-        for node_id, node in self.tree_.items():
-            if node["is_leaf"] or node.get("left_child") is None:
-                self.leaf_models_[node_id] = self._fit_pr_model(node["X"], node["y"])
-                node["is_leaf"] = True
+            if best_threshold_sse < best_overall_sse:
+                best_overall_sse = best_threshold_sse
+                best_model_params = best_threshold_params
+                best_model_params["lag_to_fit"] = _lag
+                best_model_params["threshold_lag_idx"] = threshold_lag_idx
 
+        if best_model_params:
+            # A good SETAR model was found
+            self.model_ = {"type": "setar", "params": best_model_params}
+        else:
+            # Fallback: fit a simple linear AR model
+            X, y_target = self._create_input_matrix(y, self.lag)
+            fallback_model = LinearRegression().fit(X, y_target)
+            self.model_ = {"type": "ar", "params": {"model": fallback_model}}
         return self
 
     def _predict(self, y=None, exog=None):
-        self._check_is_fitted()
-
-        # If y is not provided, we predict from the end of the training data
+        """Generate forecasts recursively."""
         if y is None:
-            history = self._last_window.flatten()
+            history = self._last_window
         else:
-            # Ensure y is 2D
-            if y.ndim == 1:
-                y = y.reshape(1, -1)
-            # We take the last 'lag' points of y for the initial prediction
-            history = y[0, -self.lag :]
+            history = y.flatten()[-self.lag :]
 
-        predictions = []
+        # Ensure history has the correct length for the model that was fitted
+        if self.model_["type"] == "setar":
+            history = history[-(self.model_["params"]["lag_to_fit"]) :]
+        else:
+            history = history[-self.lag :]
 
+        predictions = []
         for _ in range(self.horizon):
-            # Find the leaf node for the current history
-            current_node_id = 0
-            while not self.tree_[current_node_id]["is_leaf"]:
-                node = self.tree_[current_node_id]
-                split_info = node["split_info"]
+            # Reshape history for prediction
+            history_2d = history.reshape(1, -1)
 
-                # Lags are flipped to match the paper's L1, L2... convention
-                lag_val = np.flip(history)[split_info["lag_idx"]]
+            if self.model_["type"] == "setar":
+                params = self.model_["params"]
+                threshold_val = history[-(params["threshold_lag_idx"] + 1)]
 
-                if lag_val < split_info["threshold"]:
-                    current_node_id = node["left_child"]
+                if threshold_val < params["threshold"]:
+                    model_to_use = params["model_left"]
                 else:
-                    current_node_id = node["right_child"]
+                    model_to_use = params["model_right"]
+                next_pred = model_to_use.predict(history_2d)[0]
+            else:  # 'ar'
+                model_to_use = self.model_["params"]["model"]
+                next_pred = model_to_use.predict(history_2d)[0]
 
-            # Predict using the leaf's model
-            leaf_model = self.leaf_models_[current_node_id]
-            next_pred = leaf_model.predict(history.reshape(1, -1))[0]
             predictions.append(next_pred)
-
-            # Update history for the next prediction
+            # Update history for the next recursive step
             history = np.append(history[1:], next_pred)
 
-        # Now I believe predict horizen steps forward is more natural
-        # than predict just one step at the horizen position...
-        # direct / recursive?
-        # return np.array(predictions[self.horizon - 1])
-        return np.array(predictions)
+        return np.array(predictions[self.horizon - 1])
diff --git a/aeon/forecasting/_setartree.py b/aeon/forecasting/_setartree.py
new file mode 100644
index 0000000000..c76f54a354
--- /dev/null
+++ b/aeon/forecasting/_setartree.py
@@ -0,0 +1,293 @@
+"""SETAR-Tree: A tree algorithm for global time series forecasting."""
+
+import numpy as np
+from scipy.stats import f
+from sklearn.linear_model import LinearRegression
+
+from aeon.forecasting.base import BaseForecaster
+
+__maintainer__ = ["TinaJin0228"]
+__all__ = ["SetartreeForecaster"]
+
+
+class SetartreeForecaster(BaseForecaster):
+    """
+    SETAR-Tree: A tree algorithm for global time series forecasting.
+
+    This implementation is based on the paper "SETAR-Tree: a novel and accurate
+    tree algorithm for global time series forecasting" by Godahewa, R., et al. (2023).
+
+    Parameters
+    ----------
+    lag : int, default=10
+        The number of past lags to use as features for forecasting.
+    horizon : int, default=1
+        The number of time steps ahead to forecast.
+    max_depth : int, default=10
+        The maximum depth of the tree.
+    stopping_criteria : {"lin_test", "error_imp", "both"}, default="both"
+        The criteria to use for stopping tree growth:
+        - "lin_test": Uses a statistical F-test for linearity.
+        - "error_imp": Uses a minimum error reduction threshold.
+        - "both": Uses both linearity test and error improvement.
+    significance : float, default=0.05
+        The initial significance level (alpha) for the linearity F-test.
+    significance_divider : int, default=2
+        The factor by which to divide the significance level at each tree depth.
+    error_threshold : float, default=0.03
+        The minimum percentage of error reduction required to make a split.
+    """
+
+    _tags = {
+        "capability:multivariate": True,
+    }
+
+    def __init__(
+        self,
+        lag: int = 10,
+        horizon: int = 1,
+        max_depth: int = 10,
+        stopping_criteria: str = "both",
+        significance: float = 0.05,
+        significance_divider: int = 2,
+        error_threshold: float = 0.03,
+    ):
+        super().__init__(horizon=horizon, axis=1)
+        self.lag = lag
+        self.max_depth = max_depth
+        self.stopping_criteria = stopping_criteria
+        self.significance = significance
+        self.significance_divider = significance_divider
+        self.error_threshold = error_threshold
+
+        # Attributes to be fitted
+        self.tree_ = {}
+        self.leaf_models_ = {}
+
+        # for in-sample prediction when y = None in predict()
+        self._last_window = None
+
+    def _create_input_matrix(self, y: np.ndarray):
+        """Create an embedded matrix from a time series."""
+        n_series, n_timepoints = y.shape
+
+        # We need at least lag + 1 points to create one sample
+        if n_timepoints < self.lag + 1:
+            return None, None
+
+        X_list, y_list = [], []
+        for i in range(n_series):
+            series = y[i, :]
+            for j in range(len(series) - self.lag):
+                X_list.append(series[j : j + self.lag])
+                y_list.append(series[j + self.lag])
+
+        # The paper uses a convention of Lags 1, 2...
+        # we flip the columns to match the convention
+        return np.fliplr(np.array(X_list)), np.array(y_list)
+
+    def _fit_pr_model(self, X, y):
+        """Fit a Pooled Regression (linear) model."""
+        model = LinearRegression()
+        model.fit(X, y)
+        return model
+
+    def _calculate_sse(self, model, X, y):
+        """Calculate the Sum of Squared Errors (SSE)."""
+        if len(y) == 0:
+            return 0
+        predictions = model.predict(X)
+        return np.sum((y - predictions) ** 2)
+
+    def _find_optimal_split(self, X, y):
+        """Find the best lag and threshold for a split."""
+        # currently brute-force grid search method
+        best_split = {"sse": float("inf")}
+        n_samples, n_features = X.shape
+
+        for lag_idx in range(n_features):
+            thresholds = np.unique(X[:, lag_idx])
+            for t in thresholds:
+                left_indices = X[:, lag_idx] < t
+                right_indices = X[:, lag_idx] >= t
+
+                if np.sum(left_indices) == 0 or np.sum(right_indices) == 0:
+                    continue
+
+                X_left, y_left = X[left_indices], y[left_indices]
+                X_right, y_right = X[right_indices], y[right_indices]
+
+                model_left = self._fit_pr_model(X_left, y_left)
+                model_right = self._fit_pr_model(X_right, y_right)
+
+                sse_left = self._calculate_sse(model_left, X_left, y_left)
+                sse_right = self._calculate_sse(model_right, X_right, y_right)
+                total_sse = sse_left + sse_right
+
+                if total_sse < best_split["sse"]:
+                    best_split = {
+                        "sse": total_sse,
+                        "lag_idx": lag_idx,
+                        "threshold": t,
+                        "left_indices": left_indices,
+                        "right_indices": right_indices,
+                    }
+        return best_split
+
+    def _check_linearity(self, parent_sse, child_sse, n_samples, current_alpha):
+        """Perform the F-test to check for remaining non-linearity."""
+        # Degrees of freedom for parent and child models
+        # df_parent = n_samples - self.lag - 1
+        df_child = n_samples - 2 * self.lag - 2
+
+        if df_child <= 0:
+            return False
+
+        f_stat = ((parent_sse - child_sse) / (self.lag + 1)) / (child_sse / df_child)
+        p_value = 1 - f.cdf(f_stat, self.lag + 1, df_child)
+
+        return p_value < current_alpha
+
+    def _check_error_improvement(self, parent_sse, child_sse):
+        """Check if the error reduction from splitting is sufficient."""
+        if parent_sse == 0:
+            return False
+        improvement = (parent_sse - child_sse) / parent_sse
+        return improvement >= self.error_threshold
+
+    def _fit(self, y, exog=None):
+        # store last `lag` for each series
+        self._last_window = y[:, -self.lag :].copy()
+
+        X, y_embedded = self._create_input_matrix(y)
+        if X is None:
+            # If not enough data, fit a single model on what's available
+            self.tree_ = {"is_leaf": True, "node_id": 0}
+            self.leaf_models_[0] = self._fit_pr_model(y[:, :-1], y[:, -1])
+            return self
+
+        current_alpha = self.significance
+
+        # Initialize the tree with a root node
+        self.tree_ = {0: {"X": X, "y": y_embedded, "is_leaf": False}}
+        node_queue = [0]
+        next_node_id = 1
+
+        for _depth in range(self.max_depth):
+            if not node_queue:
+                break
+
+            nodes_at_this_level = list(node_queue)
+            node_queue.clear()
+
+            for node_id in nodes_at_this_level:
+                node = self.tree_[node_id]
+
+                # Try to find the best split for the current node
+                best_split = self._find_optimal_split(node["X"], node["y"])
+
+                if best_split["sse"] == float("inf"):
+                    node["is_leaf"] = True
+                    continue
+
+                # --- Stopping Criteria ---
+                parent_model = self._fit_pr_model(node["X"], node["y"])
+                parent_sse = self._calculate_sse(parent_model, node["X"], node["y"])
+                child_sse = best_split["sse"]
+
+                is_good_split = False
+                if self.stopping_criteria == "lin_test":
+                    is_good_split = self._check_linearity(
+                        parent_sse, child_sse, len(node["y"]), current_alpha
+                    )
+                elif self.stopping_criteria == "error_imp":
+                    is_good_split = self._check_error_improvement(parent_sse, child_sse)
+                elif self.stopping_criteria == "both":
+                    is_good_split = self._check_linearity(
+                        parent_sse, child_sse, len(node["y"]), current_alpha
+                    ) and self._check_error_improvement(parent_sse, child_sse)
+
+                if is_good_split:
+                    node["split_info"] = {
+                        "lag_idx": best_split["lag_idx"],
+                        "threshold": best_split["threshold"],
+                    }
+
+                    # Create left child
+                    left_id = next_node_id
+                    self.tree_[left_id] = {
+                        "X": node["X"][best_split["left_indices"]],
+                        "y": node["y"][best_split["left_indices"]],
+                        "is_leaf": False,
+                    }
+                    node["left_child"] = left_id
+                    node_queue.append(left_id)
+                    next_node_id += 1
+
+                    # Create right child
+                    right_id = next_node_id
+                    self.tree_[right_id] = {
+                        "X": node["X"][best_split["right_indices"]],
+                        "y": node["y"][best_split["right_indices"]],
+                        "is_leaf": False,
+                    }
+                    node["right_child"] = right_id
+                    node_queue.append(right_id)
+                    next_node_id += 1
+                else:
+                    node["is_leaf"] = True
+
+            # Decrease alpha for the next level
+            current_alpha /= self.significance_divider
+
+        # Fit models for all leaf nodes
+        for node_id, node in self.tree_.items():
+            if node["is_leaf"] or node.get("left_child") is None:
+                self.leaf_models_[node_id] = self._fit_pr_model(node["X"], node["y"])
+                node["is_leaf"] = True
+
+        return self
+
+    def _predict(self, y=None, exog=None):
+        self._check_is_fitted()
+
+        # If y is not provided, we predict from the end of the training data
+        if y is None:
+            history = self._last_window.flatten()
+        else:
+            # Ensure y is 2D
+            if y.ndim == 1:
+                y = y.reshape(1, -1)
+            # We take the last 'lag' points of y for the initial prediction
+            history = y[0, -self.lag :]
+
+        predictions = []
+
+        for _ in range(self.horizon):
+            # Find the leaf node for the current history
+            current_node_id = 0
+            while not self.tree_[current_node_id]["is_leaf"]:
+                node = self.tree_[current_node_id]
+                split_info = node["split_info"]
+
+                # Lags are flipped to match the paper's L1, L2... convention
+                lag_val = np.flip(history)[split_info["lag_idx"]]
+
+                if lag_val < split_info["threshold"]:
+                    current_node_id = node["left_child"]
+                else:
+                    current_node_id = node["right_child"]
+
+            # Predict using the leaf's model
+            leaf_model = self.leaf_models_[current_node_id]
+            next_pred = leaf_model.predict(history.reshape(1, -1))[0]
+            predictions.append(next_pred)
+
+            # Update history for the next prediction
+            history = np.append(history[1:], next_pred)
+
+        # Now I believe predict horizen steps forward is more natural
+        # than predict just one step at the horizen position...
+        # direct / recursive?
+        # return np.array(predictions[self.horizon - 1])
+        return np.array(predictions)
diff --git a/aeon/forecasting/tests/test_setar.py b/aeon/forecasting/tests/test_setartree.py
similarity index 98%
rename from aeon/forecasting/tests/test_setar.py
rename to aeon/forecasting/tests/test_setartree.py
index d5601a23ee..5fcd7ce6e7 100644
--- a/aeon/forecasting/tests/test_setar.py
+++ b/aeon/forecasting/tests/test_setartree.py
@@ -4,7 +4,7 @@
 import pytest
 from sklearn.linear_model import LinearRegression
 
-from aeon.forecasting._setar import SetartreeForecaster
+from aeon.forecasting._setartree import SetartreeForecaster
 
 
 def test_create_input_matrix_too_short():
diff --git a/examples/forecasting/setar.ipynb b/examples/forecasting/setar.ipynb
index 2a6dbc5702..ef3b443c87 100644
--- a/examples/forecasting/setar.ipynb
+++ b/examples/forecasting/setar.ipynb
@@ -36,7 +36,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "4c4e120c",
    "metadata": {},
    "outputs": [],
@@ -159,7 +159,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "3529d276",
    "metadata": {},
    "outputs": [
@@ -167,6 +167,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "\n",
       "--- For a Good Split ---\n",
       "Is the split statistically significant? False\n",
       "Does it meet the error threshold? True\n",
@@ -280,7 +281,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "id": "5b27b318",
    "metadata": {},
    "outputs": [
@@ -294,7 +295,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]

From 3e0460958fa3e655e75578cc73d5b2d28b0234f1 Mon Sep 17 00:00:00 2001
From: tina <jintina48@gmail.com>
Date: Thu, 26 Jun 2025 15:44:21 +0800
Subject: [PATCH 4/6] small modifications to pass the checks

---
 aeon/forecasting/_setartree.py   | 6 +-----
 examples/forecasting/setar.ipynb | 9 ++++-----
 2 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/aeon/forecasting/_setartree.py b/aeon/forecasting/_setartree.py
index c76f54a354..06e4529735 100644
--- a/aeon/forecasting/_setartree.py
+++ b/aeon/forecasting/_setartree.py
@@ -286,8 +286,4 @@ def _predict(self, y=None, exog=None):
             # Update history for the next prediction
             history = np.append(history[1:], next_pred)
 
-        # Now I believe predict horizen steps forward is more natural
-        # than predict just one step at the horizen position...
-        # direct / recursive?
-        # return np.array(predictions[self.horizon - 1])
-        return np.array(predictions)
+        return np.array(predictions[self.horizon - 1])
diff --git a/examples/forecasting/setar.ipynb b/examples/forecasting/setar.ipynb
index ef3b443c87..5eae029bc2 100644
--- a/examples/forecasting/setar.ipynb
+++ b/examples/forecasting/setar.ipynb
@@ -226,7 +226,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "4def532a",
    "metadata": {},
    "outputs": [
@@ -250,13 +250,12 @@
     "train_data = y_single[:-20].reshape(1, -1)\n",
     "\n",
     "# Fit the model\n",
-    "model_single = SetartreeForecaster(lag=10, horizon=20, max_depth=5)\n",
-    "model_single.fit(train_data)\n",
+    "model_single = SetartreeForecaster(lag=10, max_depth=5)\n",
     "\n",
     "# Get predictions\n",
     "# We can either predict from the end of the training data (y=None)\n",
     "# or provide the training data again as context.\n",
-    "predictions = model_single.predict(y=None)\n",
+    "predictions = model_single.iterative_forecast(train_data, prediction_horizon=20)\n",
     "\n",
     "# Plot the results\n",
     "plt.figure(figsize=(12, 6))\n",
@@ -281,7 +280,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "5b27b318",
    "metadata": {},
    "outputs": [

From 4673fbfb41073fa9459f90ad2b428959783036f4 Mon Sep 17 00:00:00 2001
From: tina <jintina48@gmail.com>
Date: Thu, 26 Jun 2025 15:59:04 +0800
Subject: [PATCH 5/6] to pass checks

---
 aeon/forecasting/_setar.py       |  2 +-
 aeon/forecasting/_setartree.py   |  2 +-
 examples/forecasting/setar.ipynb | 15 ++++++++++-----
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/aeon/forecasting/_setar.py b/aeon/forecasting/_setar.py
index 110d29f8ba..acebb46c77 100644
--- a/aeon/forecasting/_setar.py
+++ b/aeon/forecasting/_setar.py
@@ -151,4 +151,4 @@ def _predict(self, y=None, exog=None):
             # Update history for the next recursive step
             history = np.append(history[1:], next_pred)
 
-        return np.array(predictions[self.horizon - 1])
+        return predictions[self.horizon - 1]
diff --git a/aeon/forecasting/_setartree.py b/aeon/forecasting/_setartree.py
index 06e4529735..6e186eb88e 100644
--- a/aeon/forecasting/_setartree.py
+++ b/aeon/forecasting/_setartree.py
@@ -286,4 +286,4 @@ def _predict(self, y=None, exog=None):
             # Update history for the next prediction
             history = np.append(history[1:], next_pred)
 
-        return np.array(predictions[self.horizon - 1])
+        return predictions[self.horizon - 1]
diff --git a/examples/forecasting/setar.ipynb b/examples/forecasting/setar.ipynb
index 5eae029bc2..1811344d2c 100644
--- a/examples/forecasting/setar.ipynb
+++ b/examples/forecasting/setar.ipynb
@@ -226,7 +226,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "4def532a",
    "metadata": {},
    "outputs": [
@@ -280,7 +280,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "5b27b318",
    "metadata": {},
    "outputs": [
@@ -294,7 +294,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]
@@ -311,7 +311,8 @@
     "y_train_global = np.vstack([y_multi_1, y_multi_2])\n",
     "\n",
     "# 2. Fit the Global Model\n",
-    "global_model = SetartreeForecaster(lag=8, horizon=15, max_depth=4)\n",
+    "horizon = 15\n",
+    "global_model = SetartreeForecaster(lag=8, horizon=horizon, max_depth=4)\n",
     "global_model.fit(y_train_global)\n",
     "print(\"Global model fitted on two series.\")\n",
     "\n",
@@ -321,7 +322,11 @@
     "history_for_pred = y_new_unseen[:-15].reshape(1, -1)\n",
     "\n",
     "# 4. Predict on the Unseen Series\n",
-    "new_predictions = global_model.predict(y=history_for_pred)\n",
+    "y = history_for_pred\n",
+    "new_predictions = np.zeros(horizon)\n",
+    "for i in range(0, horizon):\n",
+    "    new_predictions[i] = global_model.predict(y)\n",
+    "    y = np.append(y, new_predictions[i])\n",
     "print(\"Generated predictions for the new, unseen series.\")\n",
     "\n",
     "# 5. Plot the results\n",

From 0ad7059a712e57f84301e9fd120741d094b0c593 Mon Sep 17 00:00:00 2001
From: tina <jintina48@gmail.com>
Date: Thu, 26 Jun 2025 17:18:19 +0800
Subject: [PATCH 6/6] delete multivariate tag since setar-tree is a univariate
 forecaster

---
 aeon/forecasting/_setartree.py           | 4 ----
 aeon/forecasting/tests/test_setartree.py | 5 +----
 examples/forecasting/setar.ipynb         | 2 +-
 3 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/aeon/forecasting/_setartree.py b/aeon/forecasting/_setartree.py
index 6e186eb88e..5362b220f4 100644
--- a/aeon/forecasting/_setartree.py
+++ b/aeon/forecasting/_setartree.py
@@ -38,10 +38,6 @@ class SetartreeForecaster(BaseForecaster):
         The minimum percentage of error reduction required to make a split.
     """
 
-    _tags = {
-        "capability:multivariate": True,
-    }
-
     def __init__(
         self,
         lag: int = 10,
diff --git a/aeon/forecasting/tests/test_setartree.py b/aeon/forecasting/tests/test_setartree.py
index 5fcd7ce6e7..3b7e15b84b 100644
--- a/aeon/forecasting/tests/test_setartree.py
+++ b/aeon/forecasting/tests/test_setartree.py
@@ -108,7 +108,4 @@ def test_predict_in_sample_basic():
     model.fit(y)
 
     pred = model._predict()  # in‐sample path
-    # should be a numpy scalar/0‐d array equal to the true next value 4
-    assert isinstance(pred, np.ndarray)
-    assert pred.shape == ()  # scalar array
-    assert pred.item() == 4
+    assert pred == 4
diff --git a/examples/forecasting/setar.ipynb b/examples/forecasting/setar.ipynb
index 1811344d2c..9512eeb4f4 100644
--- a/examples/forecasting/setar.ipynb
+++ b/examples/forecasting/setar.ipynb
@@ -21,7 +21,7 @@
    "source": [
     "## 1. Brief Introduction of the SETAR-Tree Algorithm\n",
     "\n",
-    "The SETAR-Tree algorithm introduces a hierarchical time series forecasting model that is structured as a regression tree but trained globally across multiple series. It stands out from traditional tree-based methods through two key innovations derived from the time series analysis field: \n",
+    "The SETAR-Tree algorithm introduces a global time series forecasting model that is trained globally across multiple series. It stands out from traditional univariate forecasting models through two key innovations in its tree structure: \n",
     "\n",
     "#### 1: Pooled Regression (PR) in Leaf Nodes\n",
     "Instead of simply averaging the training values that fall into a leaf node, the SETAR-Tree fits a **Pooled Regression (PR)** model in each leaf. A PR model is a global linear autoregressive model, which allows each leaf to learn from the cross-series information present in the data that falls into that specific regime.\n",