From 8ce99c9d02d95d6fb71f49ec6bbb66821b480f4b Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Sun, 7 Dec 2025 16:04:05 -0300 Subject: [PATCH 01/10] Add Robust Model Structure Selection (RMSS) implementation. Its a new algorithm for model structure selection --- .../model_structure_selection/__init__.py | 1 + ...ard_regression_orthogonal_least_squares.py | 4 +- .../model_structure_selection/ofr_base.py | 70 +- .../robust_model_structure_selection.py | 776 ++++++++++++++++++ .../sobolev_orthogonal_forward_regression.py | 4 +- .../tests/test_ofr_base.py | 5 +- .../tests/test_rmss.py | 442 ++++++++++ 7 files changed, 1290 insertions(+), 12 deletions(-) create mode 100644 sysidentpy/model_structure_selection/robust_model_structure_selection.py create mode 100644 sysidentpy/model_structure_selection/tests/test_rmss.py diff --git a/sysidentpy/model_structure_selection/__init__.py b/sysidentpy/model_structure_selection/__init__.py index b0c18ff1..7844dbaf 100644 --- a/sysidentpy/model_structure_selection/__init__.py +++ b/sysidentpy/model_structure_selection/__init__.py @@ -3,6 +3,7 @@ # License: BSD 3 clause from .forward_regression_orthogonal_least_squares import FROLS +from .robust_model_structure_selection import RMSS from .accelerated_orthogonal_least_squares import AOLS from .meta_model_structure_selection import MetaMSS from .entropic_regression import ER diff --git a/sysidentpy/model_structure_selection/forward_regression_orthogonal_least_squares.py b/sysidentpy/model_structure_selection/forward_regression_orthogonal_least_squares.py index 611c0a4d..0ee1ddb8 100644 --- a/sysidentpy/model_structure_selection/forward_regression_orthogonal_least_squares.py +++ b/sysidentpy/model_structure_selection/forward_regression_orthogonal_least_squares.py @@ -173,13 +173,15 @@ def __init__( eps: np.float64 = np.finfo(np.float64).eps, alpha: float = 0, err_tol: Optional[float] = None, + apress_lambda: float = 1.0, ): self.order_selection = order_selection self.ylag = ylag self.xlag = xlag self.max_lag = self._get_max_lag() self.info_criteria = info_criteria - self.info_criteria_function = get_info_criteria(info_criteria) + self.apress_lambda = apress_lambda + self.info_criteria_function = get_info_criteria(info_criteria, apress_lambda) self.n_info_values = n_info_values self.n_terms = n_terms self.estimator = estimator diff --git a/sysidentpy/model_structure_selection/ofr_base.py b/sysidentpy/model_structure_selection/ofr_base.py index e9b72c83..a3af0006 100644 --- a/sysidentpy/model_structure_selection/ofr_base.py +++ b/sysidentpy/model_structure_selection/ofr_base.py @@ -233,7 +233,35 @@ def bic(n_theta: int, n_samples: int, e_var: float) -> float: return info_criteria_value -def get_info_criteria(info_criteria: str): +def apress(n_theta: int, n_samples: int, mse: float, apress_lambda: float) -> float: + """Compute the APRESS criterion (eq. 9 of RMSS paper). + + Parameters + ---------- + n_theta : int + Number of selected terms (parameters). + n_samples : int + Number of available samples after lag alignment. + mse : float + Mean squared error of the model with ``n_theta`` terms. + apress_lambda : float + Small positive constant (lambda in the paper). + + Returns + ------- + float + The APRESS score for the current model size. + """ + + denom = n_samples - apress_lambda * n_theta + if denom <= 0: + # Prevent division by zero/negative scaling; fall back to large penalty. + return np.inf + scale = (n_samples / denom) ** 2 + return scale * mse + + +def get_info_criteria(info_criteria: str, apress_lambda: float = 1.0): """Get info criteria.""" info_criteria_options = { "aic": aic, @@ -241,6 +269,7 @@ def get_info_criteria(info_criteria: str): "bic": bic, "fpe": fpe, "lilc": lilc, + "apress": apress, } return info_criteria_options.get(info_criteria) @@ -292,13 +321,15 @@ def __init__( eps: np.float64 = np.finfo(np.float64).eps, alpha: float = 0, err_tol: Optional[float] = None, + apress_lambda: float = 1.0, ): self.order_selection = order_selection self.ylag = ylag self.xlag = xlag self.max_lag = self._get_max_lag() self.info_criteria = info_criteria - self.info_criteria_function = get_info_criteria(info_criteria) + self.apress_lambda = apress_lambda + self.info_criteria_function = get_info_criteria(info_criteria, apress_lambda) self.n_info_values = n_info_values self.n_terms = n_terms self.estimator = estimator @@ -366,11 +397,19 @@ def _validate_params(self): f"order_selection must be False or True. Got {self.order_selection}" ) - if self.info_criteria not in ["aic", "aicc", "bic", "fpe", "lilc"]: + if self.info_criteria not in ["aic", "aicc", "bic", "fpe", "lilc", "apress"]: raise ValueError( - f"info_criteria must be aic, bic, fpe or lilc. Got {self.info_criteria}" + f"info_criteria must be aic, aicc, bic, fpe, lilc or apress. Got {self.info_criteria}" ) + if self.info_criteria == "apress": + if not isinstance(self.apress_lambda, (int, float)): + raise TypeError( + f"apress_lambda must be a numeric value. Got {type(self.apress_lambda)}" + ) + if self.apress_lambda <= 0: + raise ValueError(f"apress_lambda must be > 0. Got {self.apress_lambda}") + if self.model_type not in ["NARMAX", "NAR", "NFIR"]: raise ValueError( f"model_type must be NARMAX, NAR or NFIR. Got {self.model_type}" @@ -470,10 +509,12 @@ def information_criterion(self, x: np.ndarray, y: np.ndarray) -> np.ndarray: This function uses a information criterion to determine the model size. 'Akaike'- Akaike's Information Criterion with - critical value 2 (AIC) (default). + critical value 2 (AIC) (default). + 'AICc' - Akaike's Information Criterion with finite-sample correction. 'Bayes' - Bayes Information Criterion (BIC). 'FPE' - Final Prediction Error (FPE). - 'LILC' - Khundrin's law ofiterated logarithm criterion (LILC). + 'LILC' - Khundrin's law of iterated logarithm criterion (LILC). + 'APRESS'- Adjustable Prediction Error Sum of Squares (paper eq. 9). Parameters ---------- @@ -515,8 +556,15 @@ def information_criterion(self, x: np.ndarray, y: np.ndarray) -> np.ndarray: tmp_yhat = np.dot(regressor_matrix, tmp_theta) tmp_residual = estimation_target - tmp_yhat - e_var = np.var(tmp_residual, ddof=1) - output_vector[i] = self.info_criteria_function(n_theta, n_samples, e_var) + + if self.info_criteria == "apress": + mse = np.mean(np.square(tmp_residual)) + output_vector[i] = apress(n_theta, n_samples, mse, self.apress_lambda) + else: + e_var = np.var(tmp_residual, ddof=1) + output_vector[i] = self.info_criteria_function( + n_theta, n_samples, e_var + ) return output_vector @@ -577,7 +625,11 @@ def fit(self, *, X: Optional[np.ndarray] = None, y: np.ndarray): self.info_values = self.information_criterion(reg_matrix, y) if self.n_terms is None and self.order_selection is True: - model_length = get_min_info_value(self.info_values) + if self.info_criteria == "apress": + # APRESS uses the minimizer of the criterion (eq. 10) + model_length = int(np.nanargmin(self.info_values)) + 1 + else: + model_length = get_min_info_value(self.info_values) self.n_terms = model_length elif self.n_terms is None and self.order_selection is not True: raise ValueError( diff --git a/sysidentpy/model_structure_selection/robust_model_structure_selection.py b/sysidentpy/model_structure_selection/robust_model_structure_selection.py new file mode 100644 index 00000000..bfe2b771 --- /dev/null +++ b/sysidentpy/model_structure_selection/robust_model_structure_selection.py @@ -0,0 +1,776 @@ +"""Robust Model Structure Selection (RMSS). + +This module implements the RMSS algorithm described in the paper attached in +``RMSS.md``. The method selects model terms using an overall mean absolute +error (OMAE) criterion computed over resampled sub-datasets (leave-one-out by +default). It follows the same interface conventions as other model structure +selection classes (e.g., :class:`~sysidentpy.model_structure_selection.FROLS`), +reusing estimators, basis functions and prediction utilities already provided +by SysIdentPy. + +Key points +---------- +- Supports all parameter estimators and basis functions available to OFR-based + classes. +- Uses leave-one-out resampling to score candidate regressors with OMAE (or + alternative error measures inspired by the paper). +- Keeps output attributes (``final_model``, ``theta``, ``pivv``) compatible + with equation formatter utilities. + +References +---------- +- Gu, Y., & Wei, H.-L. "A Robust Model Structure Selection Method for Small + Sample Size and Multiple Datasets Problems." +""" + +from __future__ import annotations + +import copy +import warnings +from typing import List, Optional, Tuple, Union + +import numpy as np + +from ..basis_function import Fourier, Polynomial +from ..utils.information_matrix import build_lagged_matrix +from ..utils.check_arrays import num_features +from .ofr_base import OFRBase, apress, get_min_info_value +from ..parameter_estimation.estimators import ( + LeastSquares, + RidgeRegression, + RecursiveLeastSquares, + TotalLeastSquares, + LeastMeanSquareMixedNorm, + LeastMeanSquares, + LeastMeanSquaresFourth, + LeastMeanSquaresLeaky, + LeastMeanSquaresNormalizedLeaky, + LeastMeanSquaresNormalizedSignRegressor, + LeastMeanSquaresNormalizedSignSign, + LeastMeanSquaresSignError, + LeastMeanSquaresSignSign, + AffineLeastMeanSquares, + NormalizedLeastMeanSquares, + NormalizedLeastMeanSquaresSignError, + LeastMeanSquaresSignRegressor, +) + +Estimators = Union[ + LeastSquares, + RidgeRegression, + RecursiveLeastSquares, + TotalLeastSquares, + LeastMeanSquareMixedNorm, + LeastMeanSquares, + LeastMeanSquaresFourth, + LeastMeanSquaresLeaky, + LeastMeanSquaresNormalizedLeaky, + LeastMeanSquaresNormalizedSignRegressor, + LeastMeanSquaresNormalizedSignSign, + LeastMeanSquaresSignError, + LeastMeanSquaresSignSign, + AffineLeastMeanSquares, + NormalizedLeastMeanSquares, + NormalizedLeastMeanSquaresSignError, + LeastMeanSquaresSignRegressor, +] + + +class RMSS(OFRBase): + r"""Robust Model Structure Selection. + + The RMSS algorithm ranks candidate regressors using an overall error metric + computed over resampled sub-datasets (leave-one-out, as suggested in the + paper for small-sample problems). At each step it selects the regressor with + the smallest aggregated error, orthogonalizes the remaining candidates, and + repeats until the desired number of terms is reached. + + Parameters + ---------- + ylag : int or list, default=2 + Maximum output lag. + xlag : int or list, default=2 + Maximum input lag. + elag : int or list, default=2 + Maximum residue lag (used when estimator requires it). + order_selection : bool, default=True + Whether to use information criteria to choose model size. + info_criteria : {'aic','aicc','bic','fpe','lilc','apress'}, default='apress' + Information criterion when ``order_selection`` is enabled. + n_terms : int, optional + Number of terms to select. Required when ``order_selection`` is False. + n_info_values : int, default=15 + Maximum number of terms evaluated by the information criterion. + estimator : Estimators, default=RecursiveLeastSquares() + Parameter estimator. + basis_function : Polynomial or Fourier, default=Polynomial() + Basis function generator. + model_type : {'NARMAX','NAR','NFIR'}, default='NARMAX' + Model type. + eps : float, default=np.finfo(np.float64).eps + Numerical stability constant. + alpha : float, default=0 + Regularization parameter (used when estimator is RidgeRegression). + err_tol : float, optional + Cumulative ERR/OMAE threshold to stop early. + resampling : {'loo','bootstrap'}, default='loo' + Resampling strategy. ``'loo'`` performs leave-one-out as proposed in the + paper. ``'bootstrap'`` draws ``n_subsets`` bootstrap samples (with + replacement) of size ``subset_size``. + error_measure : {'mae','mse','phi3','rmse_ratio'}, default='mae' + Aggregated error used to rank candidates. ``'mae'`` matches the OMAE in + the paper. ``'phi3'`` matches the normalized MAE ratio of eq. (19). + ``'smape'`` is kept as a backward-compatible alias for ``'phi3'``. + average_theta : bool, default=True + If True, estimate parameters on every sub-dataset and average the + resulting coefficients. If False, uses the estimator once on the full + data (aligned with OFRBase behaviour). + apress_lambda : float, default=1.0 + Lambda factor used in APRESS (eq. 9). Only used when + ``info_criteria='apress'``. + n_subsets : int, optional + Number of subsets to draw when ``resampling='bootstrap'``. Defaults to + ``n_samples`` (one subset per leave-one-out equivalent) when not set. + subset_size : int, optional + Subset size when ``resampling='bootstrap'``. Defaults to ``n_samples - 1`` + to mimic the sensitivity study in the paper. + random_state : int, optional + Seed for bootstrap resampling. + multi_resampling : bool, default=False + When multiple datasets are provided, apply the chosen resampling + strategy to each dataset before scoring candidates (keeps parity with + the small-sample discussion in the RMSS paper). + + Notes + ----- + - The implementation follows the same prediction and formatting interfaces + as other SysIdentPy MSS classes to remain drop-in compatible with + utilities such as ``equation_formatter``. + - Setting ``average_theta=False`` skips the per-sub-dataset averaging in + eq. (28) of the paper; keep it ``True`` for the canonical RMSS behaviour. + """ + + def __init__( + self, + *, + ylag: Union[int, list] = 2, + xlag: Union[int, list] = 2, + elag: Union[int, list] = 2, + order_selection: bool = True, + info_criteria: str = "apress", + n_terms: Union[int, None] = None, + n_info_values: int = 15, + estimator: Estimators = RecursiveLeastSquares(), + basis_function: Union[Polynomial, Fourier] = Polynomial(), + model_type: str = "NARMAX", + eps: np.float64 = np.finfo(np.float64).eps, + alpha: float = 0, + err_tol: Optional[float] = None, + resampling: str = "loo", + error_measure: str = "mae", + average_theta: bool = True, + apress_lambda: float = 1.0, + n_subsets: Optional[int] = None, + subset_size: Optional[int] = None, + random_state: Optional[int] = None, + multi_resampling: bool = False, + ): + self.resampling = resampling + self.error_measure = error_measure + self.average_theta = average_theta + self.n_subsets = n_subsets + self.subset_size = subset_size + self.random_state = random_state + self.multi_resampling = multi_resampling + self.omae_history: List[np.ndarray] = [] + self._reg_matrices: List[np.ndarray] = [] + self._targets: List[np.ndarray] = [] + + super().__init__( + ylag=ylag, + xlag=xlag, + elag=elag, + order_selection=order_selection, + info_criteria=info_criteria, + n_terms=n_terms, + n_info_values=n_info_values, + estimator=estimator, + basis_function=basis_function, + model_type=model_type, + eps=eps, + alpha=alpha, + err_tol=err_tol, + apress_lambda=apress_lambda, + ) + + self._validate_rmss_params() + + # ------------------------------------------------------------------ + # Helpers + # ------------------------------------------------------------------ + def _validate_rmss_params(self): + if self.resampling not in ["loo", "bootstrap"]: + raise ValueError(f"Unsupported resampling strategy: {self.resampling}") + + if self.error_measure == "smape": + warnings.warn( + "error_measure='smape' is deprecated; use 'phi3' (eq. 19) instead.", + DeprecationWarning, + stacklevel=2, + ) + self.error_measure = "phi3" + + valid_measures = {"mae", "mse", "phi3", "rmse_ratio"} + if self.error_measure not in valid_measures: + raise ValueError( + "error_measure must be one of 'mae', 'mse', 'phi3', 'rmse_ratio'. " + f"Got {self.error_measure}" + ) + + if not isinstance(self.average_theta, bool): + raise TypeError( + f"average_theta must be a boolean value. Got {type(self.average_theta)}" + ) + + if self.resampling == "bootstrap": + if self.n_subsets is not None and self.n_subsets < 1: + raise ValueError("n_subsets must be a positive integer when provided.") + if self.subset_size is not None and self.subset_size < 1: + raise ValueError( + "subset_size must be a positive integer when provided." + ) + if self.random_state is not None and not isinstance(self.random_state, int): + raise TypeError("random_state must be an integer when provided.") + + if not isinstance(self.multi_resampling, bool): + raise TypeError( + f"multi_resampling must be a boolean value. Got {type(self.multi_resampling)}" + ) + + def _create_sub_datasets( + self, reg_matrix: np.ndarray, target: np.ndarray + ) -> Tuple[np.ndarray, np.ndarray]: + """Generate leave-one-out or bootstrap views for a single dataset.""" + if reg_matrix.shape[0] < 2: + raise ValueError("Need at least two samples to perform RMSS resampling.") + + if self.resampling == "loo": + n_samples, n_features = reg_matrix.shape + psi_views = np.empty( + (n_samples, n_samples - 1, n_features), dtype=np.float64 + ) + y_views = np.empty((n_samples, n_samples - 1), dtype=np.float64) + + for idx in range(n_samples): + mask = np.ones(n_samples, dtype=bool) + mask[idx] = False + psi_views[idx] = reg_matrix[mask] + y_views[idx] = target[mask, 0] + + return psi_views, y_views + + if self.resampling == "bootstrap": + rng = np.random.default_rng(self.random_state) + n_samples, n_features = reg_matrix.shape + k_subsets = self.n_subsets or n_samples + subset_size = self.subset_size or max(1, n_samples - 1) + + psi_views = np.empty((k_subsets, subset_size, n_features), dtype=np.float64) + y_views = np.empty((k_subsets, subset_size), dtype=np.float64) + + for k in range(k_subsets): + idx = rng.choice(n_samples, size=subset_size, replace=True) + psi_views[k] = reg_matrix[idx] + y_views[k] = target[idx, 0] + + return psi_views, y_views + + raise ValueError(f"Unsupported resampling strategy: {self.resampling}") + + def _overall_error(self, psi_views: np.ndarray, y_views: np.ndarray) -> np.ndarray: + """Compute aggregated error for each candidate across sub-datasets.""" + # psi_views: (K, N', M), y_views: (K, N') + numerators = np.einsum("knm,kn->km", psi_views, y_views) + denominators = np.einsum("knm,knm->km", psi_views, psi_views) + denominators = np.where(np.abs(denominators) < self.eps, self.eps, denominators) + alphas = numerators / denominators + + preds = psi_views * alphas[:, None, :] + errors = y_views[:, :, None] - preds + + if self.error_measure == "mae": + metric = np.abs(errors).mean(axis=1) + elif self.error_measure == "mse": + metric = np.square(errors).mean(axis=1) + elif self.error_measure == "phi3": + numerator = np.abs(errors).sum(axis=1) + denom = np.abs(y_views).sum(axis=1)[:, None] + np.abs(preds).sum(axis=1) + denom = np.where(np.abs(denom) < self.eps, self.eps, denom) + metric = numerator / denom + else: # rmse_ratio + rmse = np.sqrt(np.square(errors).mean(axis=1)) + denom = np.sqrt(np.square(y_views).mean(axis=1))[:, None] + np.sqrt( + np.square(preds).mean(axis=1) + ) + denom = np.where(np.abs(denom) < self.eps, self.eps, denom) + metric = rmse / denom + + return metric.mean(axis=0) + + def _overall_error_multi( + self, psi_list: List[np.ndarray], y_list: List[np.ndarray] + ) -> np.ndarray: + """Compute aggregated error across multiple datasets using simple mean (eq.16).""" + + per_dataset = [] + for psi_k, y_k in zip(psi_list, y_list): + if psi_k.ndim == 3: + # Resampled views (K_k, N', M) + metric = self._overall_error(psi_k, y_k) + else: + y_vec = y_k.reshape(-1) + numerators = psi_k.T @ y_vec + denominators = np.einsum("ij,ij->j", psi_k, psi_k) + denominators = np.where( + np.abs(denominators) < self.eps, self.eps, denominators + ) + alphas = numerators / denominators + + preds = psi_k * alphas[None, :] + errors = y_vec[:, None] - preds + + if self.error_measure == "mae": + metric = np.abs(errors).mean(axis=0) + elif self.error_measure == "mse": + metric = np.square(errors).mean(axis=0) + elif self.error_measure == "phi3": + numerator = np.abs(errors).sum(axis=0) + denom = np.abs(y_vec).sum(axis=0) + np.abs(preds).sum(axis=0) + denom = np.where(np.abs(denom) < self.eps, self.eps, denom) + metric = numerator / denom + else: # rmse_ratio + rmse = np.sqrt(np.square(errors).mean(axis=0)) + denom = np.sqrt(np.square(y_k).mean(axis=0)) + np.sqrt( + np.square(preds).mean(axis=0) + ) + denom = np.where(np.abs(denom) < self.eps, self.eps, denom) + metric = rmse / denom + + per_dataset.append(metric) + + stacked = np.stack(per_dataset, axis=0) + return np.mean(stacked, axis=0) + + def _orthogonalize_remaining_views( + self, psi_views: np.ndarray, selected_q: np.ndarray + ) -> np.ndarray: + """Orthogonalize remaining candidates for resampled views (K, N', M).""" + denom = np.einsum("kn,kn->k", selected_q, selected_q) + denom = np.where(np.abs(denom) < self.eps, self.eps, denom) + + projection = np.einsum("kn,knm->km", selected_q, psi_views) + coeff = projection / denom[:, None] + return psi_views - selected_q[:, :, None] * coeff[:, None, :] + + def _orthogonalize_remaining( + self, psi_views: np.ndarray, selected_q: np.ndarray + ) -> np.ndarray: + """Orthogonalize remaining candidates against the selected vector.""" + denom = np.einsum("kn,kn->k", selected_q, selected_q) + denom = np.where(np.abs(denom) < self.eps, self.eps, denom) + + projection = np.einsum("kn,knm->km", selected_q, psi_views) + coeff = projection / denom[:, None] + psi_views = psi_views - selected_q[:, :, None] * coeff[:, None, :] + return psi_views + + def _orthogonalize_remaining_multi( + self, psi_list: List[np.ndarray], selected_q_list: List[np.ndarray] + ) -> List[np.ndarray]: + """Orthogonalize remaining candidates for multiple datasets.""" + updated = [] + for psi_k, q_k in zip(psi_list, selected_q_list): + denom = np.dot(q_k, q_k) + denom = self.eps if np.abs(denom) < self.eps else denom + projection = psi_k.T @ q_k + coeff = projection / denom + updated.append(psi_k - np.outer(q_k, coeff)) + return updated + + def _prepare_datasets( + self, + X: Optional[Union[np.ndarray, List[Optional[np.ndarray]]]], + y: Union[np.ndarray, List[np.ndarray]], + ) -> Tuple[List[np.ndarray], List[np.ndarray]]: + """Build regressor matrices/targets for single or multiple datasets.""" + if isinstance(y, (list, tuple)): + y_list = list(y) + if X is None or isinstance(X, np.ndarray): + X_list = [X for _ in y_list] + else: + X_list = list(X) + if len(X_list) != len(y_list): + raise ValueError("X and y lists must have the same length.") + + reg_matrices: List[np.ndarray] = [] + targets: List[np.ndarray] = [] + self.n_inputs = None + + for Xi, yi in zip(X_list, y_list): + lagged_data = build_lagged_matrix( + Xi, yi, self.xlag, self.ylag, self.model_type + ) + reg_matrix = self.basis_function.fit( + lagged_data, + self.max_lag, + self.ylag, + self.xlag, + self.model_type, + predefined_regressors=None, + ) + + target = self._default_estimation_target(yi) + reg_matrices.append(reg_matrix) + targets.append(target) + + if self.n_inputs is None: + self.n_inputs = num_features(Xi) if Xi is not None else 1 + elif self.n_inputs != (num_features(Xi) if Xi is not None else 1): + raise ValueError( + "All datasets must share the same input dimension." + ) + + n_features = {rm.shape[1] for rm in reg_matrices} + if len(n_features) != 1: + raise ValueError("All datasets must produce the same regressor space.") + + return reg_matrices, targets + + # Single dataset path + lagged_data = build_lagged_matrix(X, y, self.xlag, self.ylag, self.model_type) + reg_matrix = self.basis_function.fit( + lagged_data, + self.max_lag, + self.ylag, + self.xlag, + self.model_type, + predefined_regressors=None, + ) + + if X is not None: + self.n_inputs = num_features(X) + else: + self.n_inputs = 1 + + target = self._default_estimation_target(y) + return [reg_matrix], [target] + + # ------------------------------------------------------------------ + # Core MSS + # ------------------------------------------------------------------ + def run_mss_algorithm( + self, + psi: Union[np.ndarray, List[np.ndarray]], + y: Union[np.ndarray, List[np.ndarray]], + process_term_number: int, + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Perform RMSS selection over single or multiple datasets.""" + self.omae_history = [] + + if not isinstance(psi, list): + reg_matrices = [psi] + targets = [y] + else: + reg_matrices = psi + targets = y if isinstance(y, list) else [y] + + if len(reg_matrices) == 1: + psi = reg_matrices[0] + target = targets[0] + psi_views, y_views = self._create_sub_datasets(psi, target) + + available_indices = np.arange(psi.shape[1]) + selected_indices = [] + err_trace = [] + + current_views = psi_views + for _ in range(min(process_term_number, psi.shape[1])): + omae = self._overall_error(current_views, y_views) + self.omae_history.append(omae) + best_local_idx = int(np.argmin(omae)) + selected_indices.append(int(available_indices[best_local_idx])) + err_trace.append(float(omae[best_local_idx])) + + if (self.err_tol is not None) and (np.sum(err_trace) >= self.err_tol): + break + + selected_q = current_views[:, :, best_local_idx] + available_indices = np.delete(available_indices, best_local_idx) + current_views = np.delete(current_views, best_local_idx, axis=2) + + if current_views.shape[2] == 0: + break + current_views = self._orthogonalize_remaining(current_views, selected_q) + + piv = np.array(selected_indices, dtype=int) + err = np.array(err_trace, dtype=float) + psi_selected = psi[:, piv] if piv.size else psi[:, :0] + return err, piv, psi_selected, target + + # Multiple independent datasets path + psi_list: List[np.ndarray] = [] + target_list: List[np.ndarray] = [] + for rm, tgt in zip(reg_matrices, targets): + if self.multi_resampling: + views, yv = self._create_sub_datasets(rm, tgt) + psi_list.append(views) + target_list.append(yv) + else: + psi_list.append(rm.copy()) + target_list.append(tgt) + + available_indices = np.arange(psi_list[0].shape[-1]) + selected_indices: List[int] = [] + err_trace: List[float] = [] + + current_views = psi_list + for _ in range(min(process_term_number, psi_list[0].shape[-1])): + omae = self._overall_error_multi(current_views, target_list) + self.omae_history.append(omae) + best_local_idx = int(np.argmin(omae)) + selected_indices.append(int(available_indices[best_local_idx])) + err_trace.append(float(omae[best_local_idx])) + + if (self.err_tol is not None) and (np.sum(err_trace) >= self.err_tol): + break + + selected_q_list = [] + updated_views = [] + + for view in current_views: + if view.ndim == 3: + selected_q_list.append(view[:, :, best_local_idx]) + view_reduced = np.delete(view, best_local_idx, axis=2) + updated_views.append(view_reduced) + else: + selected_q_list.append(view[:, best_local_idx]) + updated_views.append(np.delete(view, best_local_idx, axis=1)) + + available_indices = np.delete(available_indices, best_local_idx) + + if updated_views[0].shape[-1] == 0: + break + + new_views = [] + for view, q in zip(updated_views, selected_q_list): + if view.ndim == 3: + new_views.append(self._orthogonalize_remaining_views(view, q)) + else: + new_views.append( + self._orthogonalize_remaining_multi([view], [q])[0] + ) + + current_views = new_views + + piv = np.array(selected_indices, dtype=int) + err = np.array(err_trace, dtype=float) + psi_selected = reg_matrices[0][:, piv] if piv.size else reg_matrices[0][:, :0] + return err, piv, psi_selected, targets[0] + + # ------------------------------------------------------------------ + # Estimation + # ------------------------------------------------------------------ + def _estimate_theta( + self, + reg_matrices: List[np.ndarray], + targets: List[np.ndarray], + piv: Optional[np.ndarray] = None, + ) -> np.ndarray: + piv = self.pivv if piv is None else piv + if piv is None or len(piv) == 0: + return np.empty((0, 1)) + + def _select_columns(mat: np.ndarray) -> np.ndarray: + return mat[:, piv] + + if len(reg_matrices) == 1: + psi = _select_columns(reg_matrices[0]) + target = targets[0] + if not self.average_theta: + warnings.warn( + "average_theta=False skips the per-subset averaging in eq.(28) " + "of the RMSS paper; use True to match the reference method.", + UserWarning, + ) + theta = self.estimator.optimize(psi, target) + else: + psi_views, y_views = self._create_sub_datasets(psi, target) + thetas = [] + for k in range(psi_views.shape[0]): + est_copy = copy.deepcopy(self.estimator) + theta_k = est_copy.optimize(psi_views[k], y_views[k].reshape(-1, 1)) + thetas.append(theta_k.reshape(-1, 1)) + theta = np.mean(np.stack(thetas, axis=2), axis=2) + + if getattr(self.estimator, "unbiased", False) is True: + theta = self.estimator.unbiased_estimator( + psi, + target, + theta, + self.elag, + self.max_lag, + self.estimator, + self.basis_function, + self.estimator.uiter, + ) + return theta + + # Multiple datasets: average parameters across datasets (eq. 28) + if getattr(self.estimator, "unbiased", False) is True: + warnings.warn( + "Unbiased correction is not applied when fitting multiple datasets " + "with RMSS; results may differ from single-dataset unbiased fits.", + UserWarning, + ) + thetas = [] + for reg_matrix, target in zip(reg_matrices, targets): + psi_sel = _select_columns(reg_matrix) + est_copy = copy.deepcopy(self.estimator) + theta_k = est_copy.optimize(psi_sel, target) + thetas.append(theta_k.reshape(-1, 1)) + + theta = np.mean(np.stack(thetas, axis=2), axis=2) + return theta + + # ------------------------------------------------------------------ + # Order selection + # ------------------------------------------------------------------ + def information_criterion( + self, + x: Union[np.ndarray, List[np.ndarray]], + y: Union[np.ndarray, List[np.ndarray]], + ) -> np.ndarray: + """Compute information criteria using robust parameter estimation.""" + reg_matrices = x if isinstance(x, list) else [x] + targets = y if isinstance(y, list) else [y] + + if ( + self.n_info_values is not None + and self.n_info_values > reg_matrices[0].shape[1] + ): + self.n_info_values = reg_matrices[0].shape[1] + + output_vector = np.zeros(self.n_info_values) + output_vector[:] = np.nan + + for i in range(self.n_info_values): + n_theta = i + 1 + _, piv, _, _ = self.run_mss_algorithm(reg_matrices, targets, n_theta) + + tmp_theta = self._estimate_theta(reg_matrices, targets, piv) + + if len(reg_matrices) == 1: + psi_sel = reg_matrices[0][:, piv] + target_sel = targets[0] + tmp_yhat = np.dot(psi_sel, tmp_theta) + tmp_residual = target_sel - tmp_yhat + + if self.info_criteria == "apress": + mse = np.mean(np.square(tmp_residual)) + output_vector[i] = apress( + n_theta, target_sel.shape[0], mse, self.apress_lambda + ) + else: + e_var = np.var(tmp_residual, ddof=1) + output_vector[i] = self.info_criteria_function( + n_theta, target_sel.shape[0], e_var + ) + else: + per_dataset_vals = [] + for rm, tgt in zip(reg_matrices, targets): + psi_sel = rm[:, piv] + yhat = np.dot(psi_sel, tmp_theta) + residual = tgt - yhat + + if self.info_criteria == "apress": + mse = np.mean(np.square(residual)) + val = apress(n_theta, tgt.shape[0], mse, self.apress_lambda) + else: + e_var = np.var(residual, ddof=1) + val = self.info_criteria_function(n_theta, tgt.shape[0], e_var) + per_dataset_vals.append(val) + + output_vector[i] = float(np.mean(per_dataset_vals)) + + # preserve pivv for downstream fit when i matches chosen n_terms + if i == self.n_info_values - 1: + self.pivv = piv + + return output_vector + + # ------------------------------------------------------------------ + # Public API + # ------------------------------------------------------------------ + def fit( + self, *, X: Optional[np.ndarray] = None, y: Union[np.ndarray, List[np.ndarray]] + ): + if y is None: + raise ValueError("y cannot be None") + + self.max_lag = self._get_max_lag() + + reg_matrices, targets = self._prepare_datasets(X, y) + self._reg_matrices = reg_matrices + self._targets = targets + + self.regressor_code = self.regressor_space(self.n_inputs) + + if self.order_selection is True: + self.info_values = self.information_criterion(reg_matrices, targets) + + if self.n_terms is None and self.order_selection is True: + if self.info_criteria == "apress": + model_length = int(np.nanargmin(self.info_values)) + 1 + else: + model_length = get_min_info_value(self.info_values) + self.n_terms = model_length + elif self.n_terms is None and self.order_selection is not True: + raise ValueError( + "If order_selection is False, you must define n_terms value." + ) + else: + model_length = self.n_terms + + mss_result = self.run_mss_algorithm(reg_matrices, targets, model_length) + self.err, self.pivv, _psi, _estimation_target = self._unpack_mss_output( + mss_result, targets[0] + ) + + model_length = min(model_length, len(self.pivv)) + self.n_terms = model_length + + tmp_piv = self.pivv[0:model_length] + repetition = len(reg_matrices[0]) + if isinstance(self.basis_function, Polynomial): + self.final_model = self.regressor_code[tmp_piv, :].copy() + else: + self.regressor_code = np.sort( + np.tile(self.regressor_code[1:, :], (repetition, 1)), + axis=0, + ) + self.final_model = self.regressor_code[tmp_piv, :].copy() + + self.theta = self._estimate_theta(self._reg_matrices, self._targets) + return self + + def predict( + self, + *, + X: Optional[np.ndarray] = None, + y: np.ndarray, + steps_ahead: Optional[int] = None, + forecast_horizon: Optional[int] = None, + ) -> np.ndarray: + return super().predict( + X=X, y=y, steps_ahead=steps_ahead, forecast_horizon=forecast_horizon + ) diff --git a/sysidentpy/model_structure_selection/sobolev_orthogonal_forward_regression.py b/sysidentpy/model_structure_selection/sobolev_orthogonal_forward_regression.py index ef99060f..59593ca1 100644 --- a/sysidentpy/model_structure_selection/sobolev_orthogonal_forward_regression.py +++ b/sysidentpy/model_structure_selection/sobolev_orthogonal_forward_regression.py @@ -268,6 +268,7 @@ def __init__( eps: np.float64 = np.finfo(np.float64).eps, alpha: float = 0, err_tol: Optional[float] = None, + apress_lambda: float = 1.0, sobolev_order: int = 2, test_support: int = 11, modulating_function: Union[ @@ -280,7 +281,8 @@ def __init__( self.xlag = xlag self.max_lag = self._get_max_lag() self.info_criteria = info_criteria - self.info_criteria_function = get_info_criteria(info_criteria) + self.apress_lambda = apress_lambda + self.info_criteria_function = get_info_criteria(info_criteria, apress_lambda) self.n_info_values = n_info_values self.n_terms = n_terms self.estimator = estimator diff --git a/sysidentpy/model_structure_selection/tests/test_ofr_base.py b/sysidentpy/model_structure_selection/tests/test_ofr_base.py index e3cff0ac..c4ba30e1 100644 --- a/sysidentpy/model_structure_selection/tests/test_ofr_base.py +++ b/sysidentpy/model_structure_selection/tests/test_ofr_base.py @@ -94,7 +94,10 @@ def test_ofrbase_initialization_invalid_info_criteria(): """Test initialization of OFRBase with an invalid info_criteria.""" with pytest.raises( ValueError, - match="info_criteria must be aic, bic, fpe or lilc. Got invalid_criteria", + match=( + r"info_criteria must be aic, aicc, bic, fpe, lilc or apress. " + r"Got invalid_criteria" + ), ): TestOFRBase( ylag=2, diff --git a/sysidentpy/model_structure_selection/tests/test_rmss.py b/sysidentpy/model_structure_selection/tests/test_rmss.py new file mode 100644 index 00000000..663887fe --- /dev/null +++ b/sysidentpy/model_structure_selection/tests/test_rmss.py @@ -0,0 +1,442 @@ +import numpy as np +import pytest + +import sysidentpy.model_structure_selection.robust_model_structure_selection as rmss_module + +from sysidentpy.model_structure_selection import RMSS +from sysidentpy.basis_function import Polynomial +from sysidentpy.parameter_estimation.estimators import LeastSquares +from sysidentpy.tests.test_narmax_base import create_test_data + +x_full, y_full, _ = create_test_data() +x_small = x_full[:60] +y_small = y_full[:60] + +split_data = 40 +X_train = np.reshape(x_small[:split_data, 0], (-1, 1)) +X_test = np.reshape(x_small[split_data:, 0], (-1, 1)) +y_train = np.reshape(y_small[:split_data, 0], (-1, 1)) +y_test = np.reshape(y_small[split_data:, 0], (-1, 1)) + + +def test_rmss_basic_fit(): + model = RMSS( + n_terms=3, + order_selection=False, + ylag=[1, 2], + xlag=2, + estimator=LeastSquares(), + basis_function=Polynomial(degree=2), + average_theta=False, + ) + + model.fit(X=X_train, y=y_train) + + assert model.final_model.shape == (3, 2) + assert model.theta.shape[0] == 3 + assert model.pivv.shape[0] == 3 + + +def test_rmss_invalid_error_measure(): + with pytest.raises(ValueError): + RMSS(error_measure="invalid", basis_function=Polynomial(degree=2)) + + +def test_rmss_predict_shape(): + model = RMSS( + n_terms=3, + order_selection=False, + ylag=[1, 2], + xlag=2, + estimator=LeastSquares(), + basis_function=Polynomial(degree=2), + average_theta=False, + ) + + model.fit(X=X_train, y=y_train) + yhat = model.predict(X=X_test, y=y_test) + assert yhat.shape == y_test.shape + + +def test_rmss_average_theta_warns(): + model = RMSS( + n_terms=2, + order_selection=False, + ylag=[1, 2], + xlag=2, + estimator=LeastSquares(), + basis_function=Polynomial(degree=2), + average_theta=False, + ) + + with pytest.warns(UserWarning, match="average_theta=False skips"): + model.fit(X=X_train, y=y_train) + + +def test_rmss_bootstrap_fit(): + model = RMSS( + n_terms=2, + order_selection=False, + ylag=[1, 2], + xlag=2, + estimator=LeastSquares(), + basis_function=Polynomial(degree=2), + resampling="bootstrap", + n_subsets=5, + subset_size=20, + random_state=0, + ) + + model.fit(X=X_train, y=y_train) + assert model.theta.shape[0] == 2 + assert model.pivv.shape[0] == 2 + + +def test_rmss_multi_dataset_unbiased_warns(): + model = RMSS( + n_terms=2, + order_selection=False, + ylag=[1, 2], + xlag=2, + estimator=LeastSquares(unbiased=True), + basis_function=Polynomial(degree=2), + ) + + X_list = [X_train, X_train] + y_list = [y_train, y_train] + + with pytest.warns(UserWarning, match="Unbiased correction is not applied"): + model.fit(X=X_list, y=y_list) + assert model.theta.shape[0] == 2 + assert model.pivv.shape[0] == 2 + + +@pytest.mark.parametrize("error_measure", ["mae", "mse", "smape", "rmse_ratio"]) +def test_rmss_error_measure_variants(error_measure): + model = RMSS( + n_terms=2, + order_selection=False, + ylag=[1, 2], + xlag=2, + estimator=LeastSquares(), + basis_function=Polynomial(degree=2), + error_measure=error_measure, + ) + + model.fit(X=X_train, y=y_train) + assert model.theta.shape[0] == 2 + + +def test_rmss_invalid_resampling(): + with pytest.raises(ValueError, match="Unsupported resampling strategy"): + RMSS(resampling="bad") + + +def test_rmss_smape_warning_sets_phi3(): + with pytest.warns(DeprecationWarning): + model = RMSS(error_measure="smape") + assert model.error_measure == "phi3" + + +def test_rmss_average_theta_type_error(): + with pytest.raises(TypeError, match="average_theta must be a boolean"): + RMSS(average_theta="yes") + + +def test_rmss_bootstrap_param_validation(): + with pytest.raises(ValueError, match="n_subsets must be a positive"): + RMSS(resampling="bootstrap", n_subsets=0) + + with pytest.raises(ValueError, match="subset_size must be a positive"): + RMSS(resampling="bootstrap", subset_size=0) + + with pytest.raises(TypeError, match="random_state must be an integer"): + RMSS(resampling="bootstrap", random_state="seed") + + +def test_rmss_multi_resampling_type_error(): + with pytest.raises(TypeError, match="multi_resampling must be a boolean"): + RMSS(multi_resampling="yes") + + +def test_create_sub_datasets_too_small(): + model = RMSS() + reg = np.ones((1, 2)) + tgt = np.ones((1, 1)) + with pytest.raises(ValueError, match="Need at least two samples"): + model._create_sub_datasets(reg, tgt) + + +@pytest.mark.parametrize("metric", ["mse", "phi3", "rmse_ratio"]) +def test_overall_error_branches(metric): + model = RMSS(error_measure=metric) + psi = np.array( + [ + [[1.0, 2.0], [2.0, 0.0]], + [[0.5, 1.5], [1.0, 1.0]], + ] + ) + y_views = np.array([[1.0, 2.0], [0.5, 1.5]]) + out = model._overall_error(psi, y_views) + assert out.shape == (2,) + + +def test_overall_error_multi_resampled_views(): + model = RMSS(error_measure="mae") + psi_views = np.array([[[1.0], [0.0]], [[2.0], [1.0]]]) + y_views = np.array([[1.0, 0.0], [2.0, 1.0]]) + metric = model._overall_error_multi([psi_views], [y_views]) + assert metric.shape == (1,) + + +def test_orthogonalize_remaining_helpers(): + model = RMSS() + psi_views = np.array( + [ + [[1.0, 0.0], [0.0, 1.0]], + [[0.5, 0.5], [0.5, -0.5]], + ] + ) + selected_q = psi_views[:, :, 0] + ortho = model._orthogonalize_remaining_views(psi_views, selected_q) + # new first column should be orthogonal to selected_q for each view + for k in range(ortho.shape[0]): + assert np.allclose(np.dot(ortho[k, :, 1], selected_q[k]), 0.0) + + psi = np.array([[1.0, 0.0], [0.0, 1.0]]) + q = psi[:, 0] + ortho_multi = model._orthogonalize_remaining_multi([psi], [q])[0] + assert np.allclose(np.dot(ortho_multi[:, 1], q), 0.0) + + +def test_prepare_datasets_length_mismatch(): + model = RMSS() + with pytest.raises(ValueError, match="X and y lists must have the same length"): + model._prepare_datasets([np.ones((5, 1))], [np.ones((5, 1)), np.ones((5, 1))]) + + +def test_prepare_datasets_input_dim_mismatch(): + model = RMSS() + X_list = [np.ones((5, 1)), np.ones((5, 2))] + y_list = [np.ones((5, 1)), np.ones((5, 1))] + with pytest.raises(ValueError): + model._prepare_datasets(X_list, y_list) + + +def test_run_mss_algorithm_err_tol_break(): + model = RMSS(err_tol=0.0) + psi = np.array([[1.0, 0.5], [0.5, 1.0]]) + y = np.array([[1.0], [0.0]]) + err, piv, _, _ = model.run_mss_algorithm(psi, y, process_term_number=2) + assert len(piv) == 1 # stopped early due to err_tol + assert err.shape[0] == 1 + + +def test_run_mss_algorithm_multi_resampling_views(): + model = RMSS(multi_resampling=True, n_terms=2, order_selection=False) + rm1 = np.array([[1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]) + rm2 = np.array([[0.5, 0.5], [1.0, 0.0], [0.0, 1.0]]) + tgt1 = np.array([[1.0], [0.0], [1.0]]) + tgt2 = np.array([[0.5], [1.0], [0.0]]) + err, piv, _, _ = model.run_mss_algorithm([rm1, rm2], [tgt1, tgt2], 2) + assert piv.size >= 1 + assert err.size >= 1 + + +def test_estimate_theta_unbiased_single_dataset(): + model = RMSS(ylag=1, xlag=1, estimator=LeastSquares(unbiased=True)) + reg = np.array([[1.0], [2.0], [3.0]]) + tgt = np.array([[1.0], [2.0], [3.0]]) + theta = model._estimate_theta([reg], [tgt], piv=np.array([0])) + assert theta.shape == (1, 1) + + +def test_information_criterion_multi_dataset_apress(): + model = RMSS(info_criteria="apress", n_info_values=2) + rm1 = np.array([[1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]) + rm2 = np.array([[1.0, 1.0], [0.5, 0.5], [0.0, 1.0]]) + tgt1 = np.array([[1.0], [0.0], [1.0]]) + tgt2 = np.array([[0.5], [1.0], [0.0]]) + info = model.information_criterion([rm1, rm2], [tgt1, tgt2]) + assert info.shape == (2,) + + +def test_fit_with_order_selection_true(): + model = RMSS( + order_selection=True, info_criteria="apress", n_terms=None, n_info_values=2 + ) + model.fit(X=X_train, y=y_train) + assert model.n_terms >= 1 + assert model.info_values.shape[0] == 2 + + +def test_fit_order_selection_false_without_n_terms(): + model = RMSS(order_selection=False, n_terms=None) + with pytest.raises(ValueError, match="define n_terms value"): + model.fit(X=X_train, y=y_train) + + +def test_create_sub_datasets_invalid_strategy_after_init(): + model = RMSS() + model.resampling = "invalid" + reg = np.ones((2, 1)) + tgt = np.ones((2, 1)) + with pytest.raises(ValueError, match="Unsupported resampling strategy"): + model._create_sub_datasets(reg, tgt) + + +def test_overall_error_multi_rmse_ratio(): + model = RMSS(error_measure="rmse_ratio") + psi_list = [np.array([[1.0, 0.0], [0.0, 1.0]])] + y_list = [np.array([[1.0], [0.0]])] + metric = model._overall_error_multi(psi_list, y_list) + assert metric.shape == (2,) + + +def test_prepare_datasets_replicates_single_x_for_list_y(): + model = RMSS() + X = np.ones((5, 1)) + y_list = [np.ones((5, 1)), np.ones((5, 1))] + reg_matrices, targets = model._prepare_datasets(X, y_list) + assert len(reg_matrices) == 2 + assert len(targets) == 2 + + +def test_prepare_datasets_regressor_space_mismatch(monkeypatch): + model = RMSS() + + call_count = {"i": 0} + + def fake_build_lagged_matrix(X, y, *args, **kwargs): + call_count["i"] += 1 + cols = 2 if call_count["i"] == 1 else 3 + return np.ones((3, cols)) + + def fake_fit(data, *args, **kwargs): + return data + + monkeypatch.setattr(rmss_module, "build_lagged_matrix", fake_build_lagged_matrix) + monkeypatch.setattr( + model, "basis_function", type("FB", (), {"fit": staticmethod(fake_fit)})() + ) + + y_list = [np.ones((3, 1)), np.ones((3, 1))] + with pytest.raises(ValueError, match="regressor space"): + model._prepare_datasets([None, None], y_list) + + +def test_prepare_datasets_num_features_mismatch(monkeypatch): + model = RMSS() + calls = {"count": 0} + + def fake_num_features(_): + calls["count"] += 1 + return 1 if calls["count"] == 1 else 2 + + monkeypatch.setattr(rmss_module, "num_features", fake_num_features) + monkeypatch.setattr( + rmss_module, "build_lagged_matrix", lambda X, y, *a, **k: np.ones((3, 2)) + ) + monkeypatch.setattr( + model, + "basis_function", + type("FB", (), {"fit": staticmethod(lambda data, *a, **k: data)})(), + ) + + with pytest.raises(ValueError, match="input dimension"): + model._prepare_datasets( + [np.ones((3, 1)), np.ones((3, 1))], [np.ones((3, 1)), np.ones((3, 1))] + ) + + +def test_prepare_datasets_single_path_sets_n_inputs_none(): + model = RMSS() + y = np.ones((5, 1)) + + # Avoid num_features(None) errors + rmss_module_build = rmss_module.build_lagged_matrix + rmss_module_basis = model.basis_function + rmss_module.build_lagged_matrix = lambda X, y, *a, **k: np.ones((3, 1)) + model.basis_function = type( + "FB", (), {"fit": staticmethod(lambda data, *a, **k: data)} + )() + + reg_matrices, targets = model._prepare_datasets(None, y) + assert model.n_inputs == 1 + assert len(reg_matrices) == 1 and len(targets) == 1 + + # restore + rmss_module.build_lagged_matrix = rmss_module_build + model.basis_function = rmss_module_basis + + +def test_run_mss_algorithm_single_feature_breaks(): + model = RMSS(n_terms=1, order_selection=False) + psi = np.array([[1.0], [0.5], [0.2]]) + y = np.array([[1.0], [0.0], [0.5]]) + err, piv, _, _ = model.run_mss_algorithm(psi, y, process_term_number=2) + assert err.size == 1 and piv.size == 1 + + +def test_run_mss_algorithm_multi_err_tol(): + model = RMSS(err_tol=0.0, n_terms=2, order_selection=False) + rm1 = np.array([[1.0, 0.0], [0.0, 1.0]]) + rm2 = np.array([[0.5, 0.5], [0.5, -0.5]]) + tgt1 = np.array([[1.0], [0.0]]) + tgt2 = np.array([[0.5], [0.5]]) + err, piv, _, _ = model.run_mss_algorithm([rm1, rm2], [tgt1, tgt2], 2) + assert err.size == 1 and piv.size == 1 + + +def test_estimate_theta_empty_piv(): + model = RMSS() + out = model._estimate_theta([np.ones((3, 1))], [np.ones((3, 1))], piv=np.array([])) + assert out.shape == (0, 1) + + +def test_information_criterion_truncate_n_info_values(): + model = RMSS(n_info_values=5) + rm = np.ones((4, 2)) + tgt = np.ones((4, 1)) + info = model.information_criterion(rm, tgt) + assert info.shape == (2,) + + +def test_information_criterion_single_non_apress(): + model = RMSS(info_criteria="aic", n_info_values=1) + rm = np.array([[1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]) + tgt = np.array([[1.0], [0.0], [1.0]]) + info = model.information_criterion(rm, tgt) + assert info.shape == (1,) + + +def test_information_criterion_multi_non_apress(): + model = RMSS(info_criteria="aic", n_info_values=1) + rm1 = np.array([[1.0, 0.0], [0.0, 1.0]]) + rm2 = np.array([[0.5, 0.5], [0.5, -0.5]]) + tgt1 = np.array([[1.0], [0.0]]) + tgt2 = np.array([[0.5], [0.5]]) + info = model.information_criterion([rm1, rm2], [tgt1, tgt2]) + assert info.shape == (1,) + + +def test_fit_y_none_raises(): + model = RMSS() + with pytest.raises(ValueError, match="y cannot be None"): + model.fit(X=X_train, y=None) + + +def test_fit_model_length_non_apress(): + model = RMSS( + order_selection=True, info_criteria="aic", n_terms=None, n_info_values=1 + ) + model.fit(X=X_train, y=y_train) + assert model.n_terms >= 1 + + +def test_fit_with_non_polynomial_basis(): + from sysidentpy.basis_function import Fourier + + model = RMSS(order_selection=False, n_terms=1, basis_function=Fourier(degree=1)) + model.fit(X=X_train, y=y_train) + assert model.final_model.shape[0] == 1 From 1d8dc85e7fe47b096367379652ab3c08cc36de27 Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Sun, 7 Dec 2025 16:11:10 -0300 Subject: [PATCH 02/10] add stacklevel in warning. Fix too long docstrings --- .../robust_model_structure_selection.py | 35 ++++++------------- 1 file changed, 10 insertions(+), 25 deletions(-) diff --git a/sysidentpy/model_structure_selection/robust_model_structure_selection.py b/sysidentpy/model_structure_selection/robust_model_structure_selection.py index bfe2b771..30db1015 100644 --- a/sysidentpy/model_structure_selection/robust_model_structure_selection.py +++ b/sysidentpy/model_structure_selection/robust_model_structure_selection.py @@ -141,13 +141,13 @@ class RMSS(OFRBase): strategy to each dataset before scoring candidates (keeps parity with the small-sample discussion in the RMSS paper). - Notes - ----- - - The implementation follows the same prediction and formatting interfaces - as other SysIdentPy MSS classes to remain drop-in compatible with - utilities such as ``equation_formatter``. - - Setting ``average_theta=False`` skips the per-sub-dataset averaging in - eq. (28) of the paper; keep it ``True`` for the canonical RMSS behaviour. + Notes + ----- + - The implementation follows the same prediction and formatting interfaces + as other SysIdentPy MSS classes to remain drop-in compatible with + utilities such as ``equation_formatter``. + - Setting ``average_theta=False`` skips the per-sub-dataset averaging in + eq. (28) of the paper; keep it ``True`` for the canonical RMSS behaviour. """ def __init__( @@ -205,9 +205,6 @@ def __init__( self._validate_rmss_params() - # ------------------------------------------------------------------ - # Helpers - # ------------------------------------------------------------------ def _validate_rmss_params(self): if self.resampling not in ["loo", "bootstrap"]: raise ValueError(f"Unsupported resampling strategy: {self.resampling}") @@ -320,8 +317,7 @@ def _overall_error(self, psi_views: np.ndarray, y_views: np.ndarray) -> np.ndarr def _overall_error_multi( self, psi_list: List[np.ndarray], y_list: List[np.ndarray] ) -> np.ndarray: - """Compute aggregated error across multiple datasets using simple mean (eq.16).""" - + """Compute aggregated error across multiple datasets using simple mean.""" per_dataset = [] for psi_k, y_k in zip(psi_list, y_list): if psi_k.ndim == 3: @@ -465,9 +461,6 @@ def _prepare_datasets( target = self._default_estimation_target(y) return [reg_matrix], [target] - # ------------------------------------------------------------------ - # Core MSS - # ------------------------------------------------------------------ def run_mss_algorithm( self, psi: Union[np.ndarray, List[np.ndarray]], @@ -577,9 +570,6 @@ def run_mss_algorithm( psi_selected = reg_matrices[0][:, piv] if piv.size else reg_matrices[0][:, :0] return err, piv, psi_selected, targets[0] - # ------------------------------------------------------------------ - # Estimation - # ------------------------------------------------------------------ def _estimate_theta( self, reg_matrices: List[np.ndarray], @@ -601,6 +591,7 @@ def _select_columns(mat: np.ndarray) -> np.ndarray: "average_theta=False skips the per-subset averaging in eq.(28) " "of the RMSS paper; use True to match the reference method.", UserWarning, + stacklevel=2 ) theta = self.estimator.optimize(psi, target) else: @@ -631,6 +622,7 @@ def _select_columns(mat: np.ndarray) -> np.ndarray: "Unbiased correction is not applied when fitting multiple datasets " "with RMSS; results may differ from single-dataset unbiased fits.", UserWarning, + stacklevel=2 ) thetas = [] for reg_matrix, target in zip(reg_matrices, targets): @@ -642,9 +634,6 @@ def _select_columns(mat: np.ndarray) -> np.ndarray: theta = np.mean(np.stack(thetas, axis=2), axis=2) return theta - # ------------------------------------------------------------------ - # Order selection - # ------------------------------------------------------------------ def information_criterion( self, x: Union[np.ndarray, List[np.ndarray]], @@ -702,15 +691,11 @@ def information_criterion( output_vector[i] = float(np.mean(per_dataset_vals)) - # preserve pivv for downstream fit when i matches chosen n_terms if i == self.n_info_values - 1: self.pivv = piv return output_vector - # ------------------------------------------------------------------ - # Public API - # ------------------------------------------------------------------ def fit( self, *, X: Optional[np.ndarray] = None, y: Union[np.ndarray, List[np.ndarray]] ): From 64a732ccec00a12d46a3bef2579d1742457cb8f6 Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Mon, 8 Dec 2025 14:36:17 -0300 Subject: [PATCH 03/10] Improve RMSS robustness and style --- .../robust_model_structure_selection.py | 69 ++++++++++--------- 1 file changed, 37 insertions(+), 32 deletions(-) diff --git a/sysidentpy/model_structure_selection/robust_model_structure_selection.py b/sysidentpy/model_structure_selection/robust_model_structure_selection.py index 30db1015..58358877 100644 --- a/sysidentpy/model_structure_selection/robust_model_structure_selection.py +++ b/sysidentpy/model_structure_selection/robust_model_structure_selection.py @@ -27,6 +27,7 @@ import copy import warnings +from itertools import repeat from typing import List, Optional, Tuple, Union import numpy as np @@ -101,8 +102,8 @@ class RMSS(OFRBase): Number of terms to select. Required when ``order_selection`` is False. n_info_values : int, default=15 Maximum number of terms evaluated by the information criterion. - estimator : Estimators, default=RecursiveLeastSquares() - Parameter estimator. + estimator : Estimators, optional + Parameter estimator. Defaults to ``RecursiveLeastSquares()`` when not provided. basis_function : Polynomial or Fourier, default=Polynomial() Basis function generator. model_type : {'NARMAX','NAR','NFIR'}, default='NARMAX' @@ -160,7 +161,7 @@ def __init__( info_criteria: str = "apress", n_terms: Union[int, None] = None, n_info_values: int = 15, - estimator: Estimators = RecursiveLeastSquares(), + estimator: Optional[Estimators] = None, basis_function: Union[Polynomial, Fourier] = Polynomial(), model_type: str = "NARMAX", eps: np.float64 = np.finfo(np.float64).eps, @@ -186,6 +187,8 @@ def __init__( self._reg_matrices: List[np.ndarray] = [] self._targets: List[np.ndarray] = [] + estimator = RecursiveLeastSquares() if estimator is None else estimator + super().__init__( ylag=ylag, xlag=xlag, @@ -319,7 +322,7 @@ def _overall_error_multi( ) -> np.ndarray: """Compute aggregated error across multiple datasets using simple mean.""" per_dataset = [] - for psi_k, y_k in zip(psi_list, y_list): + for psi_k, y_k in zip(psi_list, y_list, strict=True): if psi_k.ndim == 3: # Resampled views (K_k, N', M) metric = self._overall_error(psi_k, y_k) @@ -344,7 +347,7 @@ def _overall_error_multi( denom = np.abs(y_vec).sum(axis=0) + np.abs(preds).sum(axis=0) denom = np.where(np.abs(denom) < self.eps, self.eps, denom) metric = numerator / denom - else: # rmse_ratio + else: rmse = np.sqrt(np.square(errors).mean(axis=0)) denom = np.sqrt(np.square(y_k).mean(axis=0)) + np.sqrt( np.square(preds).mean(axis=0) @@ -380,18 +383,24 @@ def _orthogonalize_remaining( psi_views = psi_views - selected_q[:, :, None] * coeff[:, None, :] return psi_views + def _orthogonalize_matrix( + self, psi_matrix: np.ndarray, selected_q: np.ndarray + ) -> np.ndarray: + """Orthogonalize a 2D regressor matrix against the selected vector.""" + denom = np.dot(selected_q, selected_q) + denom = self.eps if np.abs(denom) < self.eps else denom + projection = psi_matrix.T @ selected_q + coeff = projection / denom + return psi_matrix - np.outer(selected_q, coeff) + def _orthogonalize_remaining_multi( self, psi_list: List[np.ndarray], selected_q_list: List[np.ndarray] ) -> List[np.ndarray]: """Orthogonalize remaining candidates for multiple datasets.""" - updated = [] - for psi_k, q_k in zip(psi_list, selected_q_list): - denom = np.dot(q_k, q_k) - denom = self.eps if np.abs(denom) < self.eps else denom - projection = psi_k.T @ q_k - coeff = projection / denom - updated.append(psi_k - np.outer(q_k, coeff)) - return updated + return [ + self._orthogonalize_matrix(psi_k, q_k) + for psi_k, q_k in zip(psi_list, selected_q_list, strict=True) + ] def _prepare_datasets( self, @@ -402,7 +411,7 @@ def _prepare_datasets( if isinstance(y, (list, tuple)): y_list = list(y) if X is None or isinstance(X, np.ndarray): - X_list = [X for _ in y_list] + X_list = list(repeat(X, len(y_list))) else: X_list = list(X) if len(X_list) != len(y_list): @@ -412,7 +421,7 @@ def _prepare_datasets( targets: List[np.ndarray] = [] self.n_inputs = None - for Xi, yi in zip(X_list, y_list): + for Xi, yi in zip(X_list, y_list, strict=True): lagged_data = build_lagged_matrix( Xi, yi, self.xlag, self.ylag, self.model_type ) @@ -513,7 +522,7 @@ def run_mss_algorithm( # Multiple independent datasets path psi_list: List[np.ndarray] = [] target_list: List[np.ndarray] = [] - for rm, tgt in zip(reg_matrices, targets): + for rm, tgt in zip(reg_matrices, targets, strict=True): if self.multi_resampling: views, yv = self._create_sub_datasets(rm, tgt) psi_list.append(views) @@ -555,13 +564,11 @@ def run_mss_algorithm( break new_views = [] - for view, q in zip(updated_views, selected_q_list): + for view, q in zip(updated_views, selected_q_list, strict=True): if view.ndim == 3: new_views.append(self._orthogonalize_remaining_views(view, q)) else: - new_views.append( - self._orthogonalize_remaining_multi([view], [q])[0] - ) + new_views.append(self._orthogonalize_matrix(view, q)) current_views = new_views @@ -591,7 +598,7 @@ def _select_columns(mat: np.ndarray) -> np.ndarray: "average_theta=False skips the per-subset averaging in eq.(28) " "of the RMSS paper; use True to match the reference method.", UserWarning, - stacklevel=2 + stacklevel=2, ) theta = self.estimator.optimize(psi, target) else: @@ -622,10 +629,10 @@ def _select_columns(mat: np.ndarray) -> np.ndarray: "Unbiased correction is not applied when fitting multiple datasets " "with RMSS; results may differ from single-dataset unbiased fits.", UserWarning, - stacklevel=2 + stacklevel=2, ) thetas = [] - for reg_matrix, target in zip(reg_matrices, targets): + for reg_matrix, target in zip(reg_matrices, targets, strict=True): psi_sel = _select_columns(reg_matrix) est_copy = copy.deepcopy(self.estimator) theta_k = est_copy.optimize(psi_sel, target) @@ -643,16 +650,14 @@ def information_criterion( reg_matrices = x if isinstance(x, list) else [x] targets = y if isinstance(y, list) else [y] - if ( - self.n_info_values is not None - and self.n_info_values > reg_matrices[0].shape[1] - ): - self.n_info_values = reg_matrices[0].shape[1] + n_info_values = self.n_info_values or reg_matrices[0].shape[1] + n_info_values = min(n_info_values, reg_matrices[0].shape[1]) + self.n_info_values = n_info_values - output_vector = np.zeros(self.n_info_values) + output_vector = np.zeros(n_info_values) output_vector[:] = np.nan - for i in range(self.n_info_values): + for i in range(n_info_values): n_theta = i + 1 _, piv, _, _ = self.run_mss_algorithm(reg_matrices, targets, n_theta) @@ -676,7 +681,7 @@ def information_criterion( ) else: per_dataset_vals = [] - for rm, tgt in zip(reg_matrices, targets): + for rm, tgt in zip(reg_matrices, targets, strict=True): psi_sel = rm[:, piv] yhat = np.dot(psi_sel, tmp_theta) residual = tgt - yhat @@ -691,7 +696,7 @@ def information_criterion( output_vector[i] = float(np.mean(per_dataset_vals)) - if i == self.n_info_values - 1: + if i == n_info_values - 1: self.pivv = piv return output_vector From c3a2ec74b73f202eee31d21f2041af666fa0f8dc Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Mon, 8 Dec 2025 15:11:40 -0300 Subject: [PATCH 04/10] Improve RMSS robustness and style --- examples/air-passenger-benchmark.ipynb | 71 +- .../robust_model_structure_selection.py | 716 +++++++++++++----- 2 files changed, 523 insertions(+), 264 deletions(-) diff --git a/examples/air-passenger-benchmark.ipynb b/examples/air-passenger-benchmark.ipynb index 24b1087f..0ca6f959 100644 --- a/examples/air-passenger-benchmark.ipynb +++ b/examples/air-passenger-benchmark.ipynb @@ -46,30 +46,7 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\wilso\\miniconda3\\envs\\neural_prophet\\lib\\site-packages\\sktime\\datatypes\\_series\\_check.py:43: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", - " VALID_INDEX_TYPES = (pd.Int64Index, pd.RangeIndex, pd.PeriodIndex, pd.DatetimeIndex)\n", - "c:\\Users\\wilso\\miniconda3\\envs\\neural_prophet\\lib\\site-packages\\sktime\\datatypes\\_panel\\_check.py:45: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", - " VALID_INDEX_TYPES = (pd.Int64Index, pd.RangeIndex, pd.PeriodIndex, pd.DatetimeIndex)\n", - "c:\\Users\\wilso\\miniconda3\\envs\\neural_prophet\\lib\\site-packages\\sktime\\datatypes\\_panel\\_check.py:46: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", - " VALID_MULTIINDEX_TYPES = (pd.Int64Index, pd.RangeIndex)\n", - "c:\\Users\\wilso\\miniconda3\\envs\\neural_prophet\\lib\\site-packages\\sktime\\utils\\validation\\series.py:18: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", - " VALID_INDEX_TYPES = (pd.Int64Index, pd.RangeIndex, pd.PeriodIndex, pd.DatetimeIndex)\n", - "c:\\Users\\wilso\\miniconda3\\envs\\neural_prophet\\lib\\site-packages\\sktime\\forecasting\\base\\_fh.py:18: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", - " RELATIVE_TYPES = (pd.Int64Index, pd.RangeIndex)\n", - "c:\\Users\\wilso\\miniconda3\\envs\\neural_prophet\\lib\\site-packages\\sktime\\forecasting\\base\\_fh.py:19: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", - " ABSOLUTE_TYPES = (pd.Int64Index, pd.RangeIndex, pd.DatetimeIndex, pd.PeriodIndex)\n", - "c:\\Users\\wilso\\miniconda3\\envs\\neural_prophet\\lib\\site-packages\\statsmodels\\tsa\\base\\tsa_model.py:7: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", - " from pandas import (to_datetime, Int64Index, DatetimeIndex, Period,\n", - "c:\\Users\\wilso\\miniconda3\\envs\\neural_prophet\\lib\\site-packages\\statsmodels\\tsa\\base\\tsa_model.py:7: FutureWarning: pandas.Float64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", - " from pandas import (to_datetime, Int64Index, DatetimeIndex, Period,\n" - ] - } - ], + "outputs": [], "source": [ "from warnings import simplefilter\n", "import matplotlib.pyplot as plt\n", @@ -91,7 +68,7 @@ "\n", "scipy.signal.signaltools._centered = _centered\n", "\n", - "from sysidentpy.model_structure_selection import FROLS\n", + "from sysidentpy.model_structure_selection import FROLS, RMSS\n", "from sysidentpy.model_structure_selection import AOLS\n", "from sysidentpy.model_structure_selection import MetaMSS\n", "from sysidentpy.basis_function import Polynomial\n", @@ -114,8 +91,8 @@ "from sktime.forecasting.model_selection import temporal_train_test_split\n", "from sktime.performance_metrics.forecasting import mean_squared_error\n", "from sktime.utils.plotting import plot_series\n", - "from neuralprophet import NeuralProphet\n", - "from neuralprophet import set_random_seed\n", + "# from neuralprophet import NeuralProphet\n", + "# from neuralprophet import set_random_seed\n", "\n", "\n", "simplefilter(\"ignore\", FutureWarning)\n", @@ -147,14 +124,12 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -198,29 +173,19 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 12, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\wilso\\Desktop\\projects\\GitHub\\sysidentpy\\sysidentpy\\model_structure_selection\\forward_regression_orthogonal_least_squares.py:619: UserWarning:\n", - "\n", - "n_info_values is greater than the maximum number of all regressors space considering the chosen y_lag, u_lag, and non_degree. We set as 14\n", - "\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "805.9521186338106\n" + "1331.7076183019103\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -236,11 +201,14 @@ "y_test = y_test.values.reshape(-1, 1)\n", "\n", "basis_function = Polynomial(degree=1)\n", - "sysidentpy = FROLS(\n", + "sysidentpy = RMSS(\n", " order_selection=True,\n", " ylag=13, # the lags for all models will be 13\n", " basis_function=basis_function,\n", " model_type=\"NAR\",\n", + " subset_size=30,\n", + " info_criteria=\"apress\",\n", + " error_measure=\"phi3\"\n", ")\n", "sysidentpy.fit(y=y_train)\n", "y_test = np.concatenate([y_train[-sysidentpy.max_lag :], y_test])\n", @@ -1020,7 +988,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.11 ('neural_prophet')", + "display_name": "sys07", "language": "python", "name": "python3" }, @@ -1034,14 +1002,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.11" + "version": "3.14.0" }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "9c8b4f2566ee0665c300a0345d74a67c0dbdc59cdceb21f2c0a51a43b1bc6af5" - } - } + "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 diff --git a/sysidentpy/model_structure_selection/robust_model_structure_selection.py b/sysidentpy/model_structure_selection/robust_model_structure_selection.py index 58358877..c54d2404 100644 --- a/sysidentpy/model_structure_selection/robust_model_structure_selection.py +++ b/sysidentpy/model_structure_selection/robust_model_structure_selection.py @@ -28,53 +28,25 @@ import copy import warnings from itertools import repeat -from typing import List, Optional, Tuple, Union +from typing import List, Literal, Optional, Tuple, Union import numpy as np from ..basis_function import Fourier, Polynomial -from ..utils.information_matrix import build_lagged_matrix +from ..parameter_estimation.estimators import RecursiveLeastSquares from ..utils.check_arrays import num_features -from .ofr_base import OFRBase, apress, get_min_info_value -from ..parameter_estimation.estimators import ( - LeastSquares, - RidgeRegression, - RecursiveLeastSquares, - TotalLeastSquares, - LeastMeanSquareMixedNorm, - LeastMeanSquares, - LeastMeanSquaresFourth, - LeastMeanSquaresLeaky, - LeastMeanSquaresNormalizedLeaky, - LeastMeanSquaresNormalizedSignRegressor, - LeastMeanSquaresNormalizedSignSign, - LeastMeanSquaresSignError, - LeastMeanSquaresSignSign, - AffineLeastMeanSquares, - NormalizedLeastMeanSquares, - NormalizedLeastMeanSquaresSignError, - LeastMeanSquaresSignRegressor, -) - -Estimators = Union[ - LeastSquares, - RidgeRegression, - RecursiveLeastSquares, - TotalLeastSquares, - LeastMeanSquareMixedNorm, - LeastMeanSquares, - LeastMeanSquaresFourth, - LeastMeanSquaresLeaky, - LeastMeanSquaresNormalizedLeaky, - LeastMeanSquaresNormalizedSignRegressor, - LeastMeanSquaresNormalizedSignSign, - LeastMeanSquaresSignError, - LeastMeanSquaresSignSign, - AffineLeastMeanSquares, - NormalizedLeastMeanSquares, - NormalizedLeastMeanSquaresSignError, - LeastMeanSquaresSignRegressor, -] +from ..utils.information_matrix import build_lagged_matrix +from .ofr_base import Estimators, OFRBase, apress, get_min_info_value + +# Type aliases for RMSS-specific parameters +ResamplingStrategy = Literal["loo", "bootstrap"] +ErrorMeasure = Literal["mae", "mse", "phi3", "rmse_ratio"] +ModelType = Literal["NARMAX", "NAR", "NFIR"] + +# Valid parameter sets for validation +_VALID_RESAMPLING_STRATEGIES: frozenset[str] = frozenset({"loo", "bootstrap"}) +_VALID_ERROR_MEASURES: frozenset[str] = frozenset({"mae", "mse", "phi3", "rmse_ratio"}) +_DEPRECATED_ERROR_MEASURES: dict[str, str] = {"smape": "phi3"} class RMSS(OFRBase): @@ -154,21 +126,21 @@ class RMSS(OFRBase): def __init__( self, *, - ylag: Union[int, list] = 2, - xlag: Union[int, list] = 2, - elag: Union[int, list] = 2, + ylag: Union[int, List[int]] = 2, + xlag: Union[int, List[int]] = 2, + elag: Union[int, List[int]] = 2, order_selection: bool = True, info_criteria: str = "apress", - n_terms: Union[int, None] = None, + n_terms: Optional[int] = None, n_info_values: int = 15, estimator: Optional[Estimators] = None, basis_function: Union[Polynomial, Fourier] = Polynomial(), - model_type: str = "NARMAX", - eps: np.float64 = np.finfo(np.float64).eps, - alpha: float = 0, + model_type: ModelType = "NARMAX", + eps: float = np.finfo(np.float64).eps, + alpha: float = 0.0, err_tol: Optional[float] = None, - resampling: str = "loo", - error_measure: str = "mae", + resampling: ResamplingStrategy = "loo", + error_measure: ErrorMeasure = "mae", average_theta: bool = True, apress_lambda: float = 1.0, n_subsets: Optional[int] = None, @@ -208,43 +180,81 @@ def __init__( self._validate_rmss_params() - def _validate_rmss_params(self): - if self.resampling not in ["loo", "bootstrap"]: - raise ValueError(f"Unsupported resampling strategy: {self.resampling}") + def _validate_rmss_params(self) -> None: + """Validate RMSS-specific parameters. + + Raises + ------ + ValueError + If resampling strategy or error measure is invalid, or if + bootstrap parameters are out of range. + TypeError + If boolean or integer parameters have wrong types. + """ + self._validate_resampling_strategy() + self._validate_error_measure() + self._validate_boolean_params() + self._validate_bootstrap_params() + + def _validate_resampling_strategy(self) -> None: + """Validate resampling strategy parameter.""" + if self.resampling not in _VALID_RESAMPLING_STRATEGIES: + valid_options = ", ".join(sorted(_VALID_RESAMPLING_STRATEGIES)) + raise ValueError( + f"Unsupported resampling strategy: '{self.resampling}'. " + f"Valid options are: {valid_options}." + ) - if self.error_measure == "smape": + def _validate_error_measure(self) -> None: + """Validate error measure parameter, handling deprecated aliases.""" + if self.error_measure in _DEPRECATED_ERROR_MEASURES: + new_measure = _DEPRECATED_ERROR_MEASURES[self.error_measure] warnings.warn( - "error_measure='smape' is deprecated; use 'phi3' (eq. 19) instead.", + f"error_measure='{self.error_measure}' is deprecated; " + f"use '{new_measure}' instead.", DeprecationWarning, - stacklevel=2, + stacklevel=3, ) - self.error_measure = "phi3" + self.error_measure = new_measure - valid_measures = {"mae", "mse", "phi3", "rmse_ratio"} - if self.error_measure not in valid_measures: + if self.error_measure not in _VALID_ERROR_MEASURES: + valid_options = ", ".join(sorted(_VALID_ERROR_MEASURES)) raise ValueError( - "error_measure must be one of 'mae', 'mse', 'phi3', 'rmse_ratio'. " - f"Got {self.error_measure}" - ) - - if not isinstance(self.average_theta, bool): - raise TypeError( - f"average_theta must be a boolean value. Got {type(self.average_theta)}" + f"error_measure must be one of: {valid_options}. " + f"Got '{self.error_measure}'." ) - if self.resampling == "bootstrap": - if self.n_subsets is not None and self.n_subsets < 1: - raise ValueError("n_subsets must be a positive integer when provided.") - if self.subset_size is not None and self.subset_size < 1: - raise ValueError( - "subset_size must be a positive integer when provided." + def _validate_boolean_params(self) -> None: + """Validate boolean parameters.""" + bool_params = { + "average_theta": self.average_theta, + "multi_resampling": self.multi_resampling, + } + for name, value in bool_params.items(): + if not isinstance(value, bool): + raise TypeError( + f"{name} must be a boolean value. Got {type(value).__name__}." ) - if self.random_state is not None and not isinstance(self.random_state, int): - raise TypeError("random_state must be an integer when provided.") - if not isinstance(self.multi_resampling, bool): + def _validate_bootstrap_params(self) -> None: + """Validate bootstrap-specific parameters.""" + if self.resampling != "bootstrap": + return + + if self.n_subsets is not None and self.n_subsets < 1: + raise ValueError( + "n_subsets must be a positive integer when provided. " + f"Got {self.n_subsets}." + ) + if self.subset_size is not None and self.subset_size < 1: + raise ValueError( + "subset_size must be a positive integer when provided. " + f"Got {self.subset_size}." + ) + if self.random_state is not None and not isinstance(self.random_state, int): raise TypeError( - f"multi_resampling must be a boolean value. Got {type(self.multi_resampling)}" + "random_state must be an integer when provided. " + f"Got {type(self.random_state).__name__}." ) def _create_sub_datasets( @@ -287,9 +297,68 @@ def _create_sub_datasets( raise ValueError(f"Unsupported resampling strategy: {self.resampling}") + def _compute_error_metric( + self, + errors: np.ndarray, + y_ref: np.ndarray, + preds: np.ndarray, + axis: int, + ) -> np.ndarray: + """Compute the selected error metric along the specified axis. + + Parameters + ---------- + errors : np.ndarray + Prediction errors (y - y_hat). + y_ref : np.ndarray + Reference output values (ground truth). + preds : np.ndarray + Model predictions. + axis : int + Axis along which to compute the metric. + + Returns + ------- + np.ndarray + Computed error metric values. + """ + if self.error_measure == "mae": + return np.abs(errors).mean(axis=axis) + + if self.error_measure == "mse": + return np.square(errors).mean(axis=axis) + + if self.error_measure == "phi3": + numerator = np.abs(errors).sum(axis=axis) + denom = np.abs(y_ref).sum(axis=axis) + np.abs(preds).sum(axis=axis) + denom = np.where(np.abs(denom) < self.eps, self.eps, denom) + return numerator / denom + + # rmse_ratio + rmse = np.sqrt(np.square(errors).mean(axis=axis)) + y_rmse = np.sqrt(np.square(y_ref).mean(axis=axis)) + pred_rmse = np.sqrt(np.square(preds).mean(axis=axis)) + denom = y_rmse + pred_rmse + denom = np.where(np.abs(denom) < self.eps, self.eps, denom) + return rmse / denom + def _overall_error(self, psi_views: np.ndarray, y_views: np.ndarray) -> np.ndarray: - """Compute aggregated error for each candidate across sub-datasets.""" - # psi_views: (K, N', M), y_views: (K, N') + """Compute aggregated error for each candidate across sub-datasets. + + Parameters + ---------- + psi_views : np.ndarray + Resampled regressor views with shape (K, N', M) where K is the + number of sub-datasets, N' is the subset size, and M is the + number of candidate regressors. + y_views : np.ndarray + Resampled target views with shape (K, N'). + + Returns + ------- + np.ndarray + Overall error for each candidate regressor (shape: M,). + """ numerators = np.einsum("knm,kn->km", psi_views, y_views) denominators = np.einsum("knm,knm->km", psi_views, psi_views) denominators = np.where(np.abs(denominators) < self.eps, self.eps, denominators) @@ -298,72 +367,86 @@ def _overall_error(self, psi_views: np.ndarray, y_views: np.ndarray) -> np.ndarr preds = psi_views * alphas[:, None, :] errors = y_views[:, :, None] - preds - if self.error_measure == "mae": - metric = np.abs(errors).mean(axis=1) - elif self.error_measure == "mse": - metric = np.square(errors).mean(axis=1) - elif self.error_measure == "phi3": - numerator = np.abs(errors).sum(axis=1) - denom = np.abs(y_views).sum(axis=1)[:, None] + np.abs(preds).sum(axis=1) - denom = np.where(np.abs(denom) < self.eps, self.eps, denom) - metric = numerator / denom - else: # rmse_ratio - rmse = np.sqrt(np.square(errors).mean(axis=1)) - denom = np.sqrt(np.square(y_views).mean(axis=1))[:, None] + np.sqrt( - np.square(preds).mean(axis=1) - ) - denom = np.where(np.abs(denom) < self.eps, self.eps, denom) - metric = rmse / denom + # Expand y_views for metric computation: (K, N') -> (K, N', 1) + y_expanded = y_views[:, :, None] + metric = self._compute_error_metric(errors, y_expanded, preds, axis=1) return metric.mean(axis=0) def _overall_error_multi( self, psi_list: List[np.ndarray], y_list: List[np.ndarray] ) -> np.ndarray: - """Compute aggregated error across multiple datasets using simple mean.""" + """Compute aggregated error across multiple datasets. + + Parameters + ---------- + psi_list : List[np.ndarray] + List of regressor matrices or resampled views per dataset. + y_list : List[np.ndarray] + List of target arrays or resampled target views per dataset. + + Returns + ------- + np.ndarray + Mean error across all datasets for each candidate. + """ per_dataset = [] for psi_k, y_k in zip(psi_list, y_list, strict=True): if psi_k.ndim == 3: - # Resampled views (K_k, N', M) + # Resampled views (K_k, N', M) - delegate to _overall_error metric = self._overall_error(psi_k, y_k) else: - y_vec = y_k.reshape(-1) - numerators = psi_k.T @ y_vec - denominators = np.einsum("ij,ij->j", psi_k, psi_k) - denominators = np.where( - np.abs(denominators) < self.eps, self.eps, denominators - ) - alphas = numerators / denominators - - preds = psi_k * alphas[None, :] - errors = y_vec[:, None] - preds - - if self.error_measure == "mae": - metric = np.abs(errors).mean(axis=0) - elif self.error_measure == "mse": - metric = np.square(errors).mean(axis=0) - elif self.error_measure == "phi3": - numerator = np.abs(errors).sum(axis=0) - denom = np.abs(y_vec).sum(axis=0) + np.abs(preds).sum(axis=0) - denom = np.where(np.abs(denom) < self.eps, self.eps, denom) - metric = numerator / denom - else: - rmse = np.sqrt(np.square(errors).mean(axis=0)) - denom = np.sqrt(np.square(y_k).mean(axis=0)) + np.sqrt( - np.square(preds).mean(axis=0) - ) - denom = np.where(np.abs(denom) < self.eps, self.eps, denom) - metric = rmse / denom - + metric = self._compute_2d_error(psi_k, y_k) per_dataset.append(metric) - stacked = np.stack(per_dataset, axis=0) - return np.mean(stacked, axis=0) + return np.mean(np.stack(per_dataset, axis=0), axis=0) + + def _compute_2d_error(self, psi: np.ndarray, y: np.ndarray) -> np.ndarray: + """Compute error metric for a 2D regressor matrix. + + Parameters + ---------- + psi : np.ndarray + Regressor matrix with shape (N, M). + y : np.ndarray + Target array with shape (N,) or (N, 1). + + Returns + ------- + np.ndarray + Error metric for each candidate (shape: M,). + """ + y_vec = y.reshape(-1) + numerators = psi.T @ y_vec + denominators = np.einsum("ij,ij->j", psi, psi) + denominators = np.where(np.abs(denominators) < self.eps, self.eps, denominators) + alphas = numerators / denominators + + preds = psi * alphas[None, :] + errors = y_vec[:, None] - preds + + return self._compute_error_metric(errors, y_vec[:, None], preds, axis=0) def _orthogonalize_remaining_views( self, psi_views: np.ndarray, selected_q: np.ndarray ) -> np.ndarray: - """Orthogonalize remaining candidates for resampled views (K, N', M).""" + """Orthogonalize remaining candidates against the selected vector. + + Applies Gram-Schmidt orthogonalization to remove the component of + each candidate regressor that lies along the selected vector. + + Parameters + ---------- + psi_views : np.ndarray + Resampled regressor views with shape (K, N', M). + selected_q : np.ndarray + Selected regressor vector with shape (K, N'). + + Returns + ------- + np.ndarray + Orthogonalized regressor views with same shape as input. + """ denom = np.einsum("kn,kn->k", selected_q, selected_q) denom = np.where(np.abs(denom) < self.eps, self.eps, denom) @@ -371,22 +454,26 @@ def _orthogonalize_remaining_views( coeff = projection / denom[:, None] return psi_views - selected_q[:, :, None] * coeff[:, None, :] - def _orthogonalize_remaining( - self, psi_views: np.ndarray, selected_q: np.ndarray - ) -> np.ndarray: - """Orthogonalize remaining candidates against the selected vector.""" - denom = np.einsum("kn,kn->k", selected_q, selected_q) - denom = np.where(np.abs(denom) < self.eps, self.eps, denom) - - projection = np.einsum("kn,knm->km", selected_q, psi_views) - coeff = projection / denom[:, None] - psi_views = psi_views - selected_q[:, :, None] * coeff[:, None, :] - return psi_views + # Alias for backward compatibility + _orthogonalize_remaining = _orthogonalize_remaining_views def _orthogonalize_matrix( self, psi_matrix: np.ndarray, selected_q: np.ndarray ) -> np.ndarray: - """Orthogonalize a 2D regressor matrix against the selected vector.""" + """Orthogonalize a 2D regressor matrix against the selected vector. + + Parameters + ---------- + psi_matrix : np.ndarray + Regressor matrix with shape (N, M). + selected_q : np.ndarray + Selected regressor vector with shape (N,). + + Returns + ------- + np.ndarray + Orthogonalized regressor matrix with same shape as input. + """ denom = np.dot(selected_q, selected_q) denom = self.eps if np.abs(denom) < self.eps else denom projection = psi_matrix.T @ selected_q @@ -396,7 +483,20 @@ def _orthogonalize_matrix( def _orthogonalize_remaining_multi( self, psi_list: List[np.ndarray], selected_q_list: List[np.ndarray] ) -> List[np.ndarray]: - """Orthogonalize remaining candidates for multiple datasets.""" + """Orthogonalize remaining candidates for multiple 2D datasets. + + Parameters + ---------- + psi_list : List[np.ndarray] + List of regressor matrices, each with shape (N_k, M). + selected_q_list : List[np.ndarray] + List of selected regressor vectors, each with shape (N_k,). + + Returns + ------- + List[np.ndarray] + List of orthogonalized regressor matrices. + """ return [ self._orthogonalize_matrix(psi_k, q_k) for psi_k, q_k in zip(psi_list, selected_q_list, strict=True) @@ -407,7 +507,29 @@ def _prepare_datasets( X: Optional[Union[np.ndarray, List[Optional[np.ndarray]]]], y: Union[np.ndarray, List[np.ndarray]], ) -> Tuple[List[np.ndarray], List[np.ndarray]]: - """Build regressor matrices/targets for single or multiple datasets.""" + """Build regressor matrices and targets for single or multiple datasets. + + Parameters + ---------- + X : np.ndarray, List[np.ndarray], or None + Input data. Can be a single array, a list of arrays for multiple + datasets, or None for NAR models. + y : np.ndarray or List[np.ndarray] + Output data. Can be a single array or a list for multiple datasets. + + Returns + ------- + Tuple[List[np.ndarray], List[np.ndarray]] + A tuple containing: + - reg_matrices: List of regressor matrices. + - targets: List of target arrays. + + Raises + ------ + ValueError + If X and y lists have different lengths, or if datasets have + inconsistent input dimensions or regressor spaces. + """ if isinstance(y, (list, tuple)): y_list = list(y) if X is None or isinstance(X, np.ndarray): @@ -476,106 +598,203 @@ def run_mss_algorithm( y: Union[np.ndarray, List[np.ndarray]], process_term_number: int, ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: - """Perform RMSS selection over single or multiple datasets.""" + """Perform RMSS selection over single or multiple datasets. + + This method implements the core RMSS algorithm, selecting regressors + one at a time based on their aggregated error across resampled + sub-datasets. + + Parameters + ---------- + psi : np.ndarray or List[np.ndarray] + Regressor matrix or list of matrices for multiple datasets. + y : np.ndarray or List[np.ndarray] + Target array or list of arrays for multiple datasets. + process_term_number : int + Maximum number of terms to select. + + Returns + ------- + Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray] + - err: Array of error values for each selected term. + - piv: Array of selected regressor indices. + - psi_selected: Regressor matrix with only selected columns. + - target: Target array used for estimation. + """ self.omae_history = [] - if not isinstance(psi, list): - reg_matrices = [psi] - targets = [y] - else: - reg_matrices = psi - targets = y if isinstance(y, list) else [y] + reg_matrices, targets = self._normalize_inputs(psi, y) if len(reg_matrices) == 1: - psi = reg_matrices[0] - target = targets[0] - psi_views, y_views = self._create_sub_datasets(psi, target) + return self._run_single_dataset( + reg_matrices[0], targets[0], process_term_number + ) - available_indices = np.arange(psi.shape[1]) - selected_indices = [] - err_trace = [] + return self._run_multi_dataset(reg_matrices, targets, process_term_number) - current_views = psi_views - for _ in range(min(process_term_number, psi.shape[1])): - omae = self._overall_error(current_views, y_views) - self.omae_history.append(omae) - best_local_idx = int(np.argmin(omae)) - selected_indices.append(int(available_indices[best_local_idx])) - err_trace.append(float(omae[best_local_idx])) + def _normalize_inputs( + self, + psi: Union[np.ndarray, List[np.ndarray]], + y: Union[np.ndarray, List[np.ndarray]], + ) -> Tuple[List[np.ndarray], List[np.ndarray]]: + """Normalize inputs to lists for consistent processing.""" + if not isinstance(psi, list): + return [psi], [y] + targets = y if isinstance(y, list) else [y] + return psi, targets - if (self.err_tol is not None) and (np.sum(err_trace) >= self.err_tol): - break + def _run_single_dataset( + self, + psi: np.ndarray, + target: np.ndarray, + process_term_number: int, + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Run RMSS selection for a single dataset.""" + psi_views, y_views = self._create_sub_datasets(psi, target) - selected_q = current_views[:, :, best_local_idx] - available_indices = np.delete(available_indices, best_local_idx) - current_views = np.delete(current_views, best_local_idx, axis=2) + available_indices = np.arange(psi.shape[1]) + selected_indices: List[int] = [] + err_trace: List[float] = [] - if current_views.shape[2] == 0: - break - current_views = self._orthogonalize_remaining(current_views, selected_q) + current_views = psi_views + max_terms = min(process_term_number, psi.shape[1]) - piv = np.array(selected_indices, dtype=int) - err = np.array(err_trace, dtype=float) - psi_selected = psi[:, piv] if piv.size else psi[:, :0] - return err, piv, psi_selected, target + for _ in range(max_terms): + omae = self._overall_error(current_views, y_views) + self.omae_history.append(omae) - # Multiple independent datasets path - psi_list: List[np.ndarray] = [] - target_list: List[np.ndarray] = [] - for rm, tgt in zip(reg_matrices, targets, strict=True): - if self.multi_resampling: - views, yv = self._create_sub_datasets(rm, tgt) - psi_list.append(views) - target_list.append(yv) - else: - psi_list.append(rm.copy()) - target_list.append(tgt) + best_local_idx = int(np.argmin(omae)) + selected_indices.append(int(available_indices[best_local_idx])) + err_trace.append(float(omae[best_local_idx])) + + if self._should_stop_selection(err_trace): + break + + selected_q = current_views[:, :, best_local_idx] + available_indices = np.delete(available_indices, best_local_idx) + current_views = np.delete(current_views, best_local_idx, axis=2) + + if current_views.shape[2] == 0: + break + + current_views = self._orthogonalize_remaining(current_views, selected_q) + + return self._build_result(selected_indices, err_trace, psi, target) + + def _run_multi_dataset( + self, + reg_matrices: List[np.ndarray], + targets: List[np.ndarray], + process_term_number: int, + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Run RMSS selection for multiple datasets.""" + psi_list, target_list = self._prepare_multi_dataset_views(reg_matrices, targets) available_indices = np.arange(psi_list[0].shape[-1]) selected_indices: List[int] = [] err_trace: List[float] = [] current_views = psi_list - for _ in range(min(process_term_number, psi_list[0].shape[-1])): + max_terms = min(process_term_number, psi_list[0].shape[-1]) + + for _ in range(max_terms): omae = self._overall_error_multi(current_views, target_list) self.omae_history.append(omae) + best_local_idx = int(np.argmin(omae)) selected_indices.append(int(available_indices[best_local_idx])) err_trace.append(float(omae[best_local_idx])) - if (self.err_tol is not None) and (np.sum(err_trace) >= self.err_tol): + if self._should_stop_selection(err_trace): break - selected_q_list = [] - updated_views = [] - - for view in current_views: - if view.ndim == 3: - selected_q_list.append(view[:, :, best_local_idx]) - view_reduced = np.delete(view, best_local_idx, axis=2) - updated_views.append(view_reduced) - else: - selected_q_list.append(view[:, best_local_idx]) - updated_views.append(np.delete(view, best_local_idx, axis=1)) - + updated_views, selected_q_list = self._extract_and_remove_selected( + current_views, best_local_idx + ) available_indices = np.delete(available_indices, best_local_idx) if updated_views[0].shape[-1] == 0: break - new_views = [] - for view, q in zip(updated_views, selected_q_list, strict=True): - if view.ndim == 3: - new_views.append(self._orthogonalize_remaining_views(view, q)) - else: - new_views.append(self._orthogonalize_matrix(view, q)) + current_views = self._orthogonalize_multi_views( + updated_views, selected_q_list + ) + + return self._build_result( + selected_indices, err_trace, reg_matrices[0], targets[0] + ) + + def _should_stop_selection(self, err_trace: List[float]) -> bool: + """Check if selection should stop based on error tolerance.""" + return self.err_tol is not None and np.sum(err_trace) >= self.err_tol + + def _prepare_multi_dataset_views( + self, + reg_matrices: List[np.ndarray], + targets: List[np.ndarray], + ) -> Tuple[List[np.ndarray], List[np.ndarray]]: + """Prepare views for multi-dataset processing.""" + psi_list: List[np.ndarray] = [] + target_list: List[np.ndarray] = [] + + for rm, tgt in zip(reg_matrices, targets, strict=True): + if self.multi_resampling: + views, yv = self._create_sub_datasets(rm, tgt) + psi_list.append(views) + target_list.append(yv) + else: + psi_list.append(rm.copy()) + target_list.append(tgt) + + return psi_list, target_list + + def _extract_and_remove_selected( + self, + views: List[np.ndarray], + best_idx: int, + ) -> Tuple[List[np.ndarray], List[np.ndarray]]: + """Extract selected regressors and remove them from views.""" + selected_q_list: List[np.ndarray] = [] + updated_views: List[np.ndarray] = [] + + for view in views: + if view.ndim == 3: + selected_q_list.append(view[:, :, best_idx]) + updated_views.append(np.delete(view, best_idx, axis=2)) + else: + selected_q_list.append(view[:, best_idx]) + updated_views.append(np.delete(view, best_idx, axis=1)) + + return updated_views, selected_q_list - current_views = new_views + def _orthogonalize_multi_views( + self, + views: List[np.ndarray], + selected_q_list: List[np.ndarray], + ) -> List[np.ndarray]: + """Orthogonalize views against selected regressors.""" + new_views: List[np.ndarray] = [] + + for view, q in zip(views, selected_q_list, strict=True): + if view.ndim == 3: + new_views.append(self._orthogonalize_remaining_views(view, q)) + else: + new_views.append(self._orthogonalize_matrix(view, q)) + return new_views + + def _build_result( + self, + selected_indices: List[int], + err_trace: List[float], + psi: np.ndarray, + target: np.ndarray, + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Build the result tuple from selection data.""" piv = np.array(selected_indices, dtype=int) err = np.array(err_trace, dtype=float) - psi_selected = reg_matrices[0][:, piv] if piv.size else reg_matrices[0][:, :0] - return err, piv, psi_selected, targets[0] + psi_selected = psi[:, piv] if piv.size else psi[:, :0] + return err, piv, psi_selected, target def _estimate_theta( self, @@ -583,6 +802,27 @@ def _estimate_theta( targets: List[np.ndarray], piv: Optional[np.ndarray] = None, ) -> np.ndarray: + """Estimate model parameters using the selected regressors. + + For a single dataset with ``average_theta=True``, parameters are + estimated on each resampled sub-dataset and averaged (eq. 28 in the + RMSS paper). For multiple datasets, parameters are averaged across + all datasets. + + Parameters + ---------- + reg_matrices : List[np.ndarray] + List of regressor matrices. + targets : List[np.ndarray] + List of target arrays. + piv : np.ndarray, optional + Indices of selected regressors. If None, uses ``self.pivv``. + + Returns + ------- + np.ndarray + Estimated parameter vector with shape (n_terms, 1). + """ piv = self.pivv if piv is None else piv if piv is None or len(piv) == 0: return np.empty((0, 1)) @@ -646,7 +886,23 @@ def information_criterion( x: Union[np.ndarray, List[np.ndarray]], y: Union[np.ndarray, List[np.ndarray]], ) -> np.ndarray: - """Compute information criteria using robust parameter estimation.""" + """Compute information criteria using robust parameter estimation. + + Evaluates models of increasing complexity (1 to ``n_info_values`` + terms) and returns the information criterion value for each. + + Parameters + ---------- + x : np.ndarray or List[np.ndarray] + Regressor matrix or list of matrices. + y : np.ndarray or List[np.ndarray] + Target array or list of arrays. + + Returns + ------- + np.ndarray + Information criterion values for each model size. + """ reg_matrices = x if isinstance(x, list) else [x] targets = y if isinstance(y, list) else [y] @@ -703,7 +959,28 @@ def information_criterion( def fit( self, *, X: Optional[np.ndarray] = None, y: Union[np.ndarray, List[np.ndarray]] - ): + ) -> "RMSS": + """Fit the RMSS model to the data. + + Parameters + ---------- + X : np.ndarray, optional + Input data with shape (n_samples, n_inputs). Can be None for + NAR models. + y : np.ndarray or List[np.ndarray] + Output data with shape (n_samples, 1). Can be a list for + fitting with multiple datasets. + + Returns + ------- + self : RMSS + The fitted model instance. + + Raises + ------ + ValueError + If y is None or if order_selection is False without n_terms. + """ if y is None: raise ValueError("y cannot be None") @@ -761,6 +1038,25 @@ def predict( steps_ahead: Optional[int] = None, forecast_horizon: Optional[int] = None, ) -> np.ndarray: + """Predict using the fitted RMSS model. + + Parameters + ---------- + X : np.ndarray, optional + Input data for prediction. Can be None for NAR models. + y : np.ndarray + Output data with initial conditions for prediction. + steps_ahead : int, optional + Number of steps ahead for multi-step prediction. If None, + performs free-run simulation. + forecast_horizon : int, optional + Number of samples to forecast beyond the input data. + + Returns + ------- + np.ndarray + Predicted output values. + """ return super().predict( X=X, y=y, steps_ahead=steps_ahead, forecast_horizon=forecast_horizon ) From 897e9d48c5813e08bbd06057348bd67808baf792 Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Mon, 8 Dec 2025 15:13:52 -0300 Subject: [PATCH 05/10] return air passenger example to default results --- examples/air-passenger-benchmark.ipynb | 27 +++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/examples/air-passenger-benchmark.ipynb b/examples/air-passenger-benchmark.ipynb index 0ca6f959..e8324941 100644 --- a/examples/air-passenger-benchmark.ipynb +++ b/examples/air-passenger-benchmark.ipynb @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -68,7 +68,7 @@ "\n", "scipy.signal.signaltools._centered = _centered\n", "\n", - "from sysidentpy.model_structure_selection import FROLS, RMSS\n", + "from sysidentpy.model_structure_selection import FROLS\n", "from sysidentpy.model_structure_selection import AOLS\n", "from sysidentpy.model_structure_selection import MetaMSS\n", "from sysidentpy.basis_function import Polynomial\n", @@ -112,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -124,7 +124,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -173,19 +173,27 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1331.7076183019103\n" + "805.9521186870579\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/wilsonrocha/Documents/RD/projects/sysidentpy/sysidentpy/model_structure_selection/ofr_base.py:625: UserWarning: n_info_values is greater than the maximum number of all regressors space considering the chosen y_lag, u_lag, and non_degree. We set as 14\n", + " self.info_values = self.information_criterion(reg_matrix, y)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -201,14 +209,11 @@ "y_test = y_test.values.reshape(-1, 1)\n", "\n", "basis_function = Polynomial(degree=1)\n", - "sysidentpy = RMSS(\n", + "sysidentpy = FROLS(\n", " order_selection=True,\n", " ylag=13, # the lags for all models will be 13\n", " basis_function=basis_function,\n", " model_type=\"NAR\",\n", - " subset_size=30,\n", - " info_criteria=\"apress\",\n", - " error_measure=\"phi3\"\n", ")\n", "sysidentpy.fit(y=y_train)\n", "y_test = np.concatenate([y_train[-sysidentpy.max_lag :], y_test])\n", From 7b113291edcd4ec25b55a5ab14a5a81c066efa97 Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Mon, 8 Dec 2025 20:36:47 -0300 Subject: [PATCH 06/10] fix down fail logic and add tests --- examples/air-passenger-benchmark.ipynb | 12 +- .../model_structure_selection/__init__.py | 1 + .../orthogonal_floating_search.py | 782 ++++++++++++++++++ .../tests/test_orthogonal_floating_search.py | 574 +++++++++++++ 4 files changed, 1363 insertions(+), 6 deletions(-) create mode 100644 sysidentpy/model_structure_selection/orthogonal_floating_search.py create mode 100644 sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py diff --git a/examples/air-passenger-benchmark.ipynb b/examples/air-passenger-benchmark.ipynb index e8324941..8f2c1cdc 100644 --- a/examples/air-passenger-benchmark.ipynb +++ b/examples/air-passenger-benchmark.ipynb @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -91,8 +91,8 @@ "from sktime.forecasting.model_selection import temporal_train_test_split\n", "from sktime.performance_metrics.forecasting import mean_squared_error\n", "from sktime.utils.plotting import plot_series\n", - "# from neuralprophet import NeuralProphet\n", - "# from neuralprophet import set_random_seed\n", + "from neuralprophet import NeuralProphet\n", + "from neuralprophet import set_random_seed\n", "\n", "\n", "simplefilter(\"ignore\", FutureWarning)\n", @@ -112,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -124,7 +124,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -173,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [ { diff --git a/sysidentpy/model_structure_selection/__init__.py b/sysidentpy/model_structure_selection/__init__.py index 7844dbaf..33168f6f 100644 --- a/sysidentpy/model_structure_selection/__init__.py +++ b/sysidentpy/model_structure_selection/__init__.py @@ -8,3 +8,4 @@ from .meta_model_structure_selection import MetaMSS from .entropic_regression import ER from .sobolev_orthogonal_forward_regression import UOFR +from .orthogonal_floating_search import OSF, OIF, OOS, O2S diff --git a/sysidentpy/model_structure_selection/orthogonal_floating_search.py b/sysidentpy/model_structure_selection/orthogonal_floating_search.py new file mode 100644 index 00000000..6bb354a4 --- /dev/null +++ b/sysidentpy/model_structure_selection/orthogonal_floating_search.py @@ -0,0 +1,782 @@ +"""Orthogonal floating search algorithms (OSF, OIF, OOS/O2S). + +The algorithms implemented here follow the Orthogonal Floating Search +framework described in the attached OFSA manuscript. They adapt +well-known floating feature selection strategies to the NARX model +structure selection problem by combining: (i) orthogonal projections of +candidate regressors and (ii) the classical Error Reduction Ratio (ERR) +criterion. All classes are drop-in compatible with the existing SysIdentPy +API (estimators, basis functions, equation formatter, etc.). +""" + +from __future__ import annotations + +from typing import List, Optional, Sequence, Tuple, Union +from itertools import combinations + +import numpy as np + +from ..basis_function import Fourier, Polynomial +from ..narmax_base import house, rowhouse +from ..parameter_estimation.estimators import RecursiveLeastSquares +from .ofr_base import Estimators, OFRBase, _compute_err_slice + + +class _OrthogonalFloatingBase(OFRBase): + """Shared helpers for the Orthogonal Floating Search family.""" + + def __init__( + self, + *, + ylag: Union[int, List[int]] = 2, + xlag: Union[int, List[int]] = 2, + elag: Union[int, List[int]] = 2, + order_selection: bool = True, + info_criteria: str = "aic", + n_terms: Optional[int] = None, + n_info_values: int = 15, + estimator: Estimators = RecursiveLeastSquares(), + basis_function: Union[Polynomial, Fourier] = Polynomial(), + model_type: str = "NARMAX", + eps: float = np.finfo(np.float64).eps, + alpha: float = 0.0, + err_tol: Optional[float] = None, + apress_lambda: float = 1.0, + ): + super().__init__( + ylag=ylag, + xlag=xlag, + elag=elag, + order_selection=order_selection, + info_criteria=info_criteria, + n_terms=n_terms, + n_info_values=n_info_values, + estimator=estimator, + basis_function=basis_function, + model_type=model_type, + eps=eps, + alpha=alpha, + err_tol=err_tol, + apress_lambda=apress_lambda, + ) + + # --------- low-level ERR utilities --------- + def _subset_err( + self, + psi: np.ndarray, + target: np.ndarray, + subset: List[int], + squared_y: float, + ) -> Tuple[float, np.ndarray]: + """Compute ERR score for a given subset (Eq. 4–5). + + The ERR of each selected regressor is computed in an orthonormal + basis obtained via QR. The returned score is the sum of ERRs, + matching J(·) in Definition 5. + """ + + if not subset: + return 0.0, np.array([]) + + psi_sel = psi[:, subset] + # Reduced QR gives orthonormal columns (||w_i||=1), aligning with + # the Gram-Schmidt-based ERR definition without explicit scaling. + q, _ = np.linalg.qr(psi_sel, mode="reduced") + g = q.T @ target + denom = squared_y if squared_y > 0 else np.finfo(np.float64).eps + err_vals = np.square(g).flatten() / denom + score = float(np.sum(err_vals)) + return score, err_vals + + def _compute_squared_y(self, target: np.ndarray) -> float: + """Compute ||y||^2 with numerical floor to avoid division by zero.""" + + squared_y = float(np.dot(target.T, target).item()) + return squared_y if squared_y > self.eps else float(self.eps) + + # --------- local search building blocks --------- + def _best_addition( + self, + psi: np.ndarray, + target: np.ndarray, + subset: List[int], + available: List[int], + squared_y: float, + ) -> Tuple[Optional[int], float]: + """Pick the most significant term (Definition 1).""" + + best_idx: Optional[int] = None + best_score = -np.inf + for idx in available: + score, _ = self._subset_err(psi, target, subset + [idx], squared_y) + if score > best_score or ( + np.isclose(score, best_score) and (best_idx is None or idx < best_idx) + ): + best_score = score + best_idx = idx + return best_idx, best_score + + def _best_removal( + self, + psi: np.ndarray, + target: np.ndarray, + subset: List[int], + squared_y: float, + ) -> Tuple[int, float]: + """Pick the least significant term (Definition 2).""" + + best_idx = subset[0] + best_score = -np.inf + for idx in subset: + remaining = [t for t in subset if t != idx] + score, _ = self._subset_err(psi, target, remaining, squared_y) + if score > best_score or (np.isclose(score, best_score) and idx < best_idx): + best_score = score + best_idx = idx + return best_idx, best_score + + def _most_significant_terms( + self, + psi: np.ndarray, + target: np.ndarray, + subset: List[int], + available: List[int], + count: int, + squared_y: float, + ) -> List[int]: + """Exhaustive selection of the most significant ``count``-subset (Definition 3).""" + + k = min(count, len(available)) + if k <= 0: + return [] + + best_score = -np.inf + best_combo: Optional[Tuple[int, ...]] = None + + for combo in combinations(available, k): + score, _ = self._subset_err(psi, target, subset + list(combo), squared_y) + if score > best_score or ( + np.isclose(score, best_score) + and (best_combo is None or combo < best_combo) + ): + best_score = score + best_combo = combo + + return list(best_combo) if best_combo is not None else [] + + def _least_significant_terms( + self, + psi: np.ndarray, + target: np.ndarray, + subset: List[int], + count: int, + squared_y: float, + ) -> List[int]: + """Exhaustive removal of the least significant ``count``-subset (Definition 4).""" + + k = min(count, len(subset)) + if k <= 0: + return [] + + best_score = -np.inf + best_combo: Optional[Tuple[int, ...]] = None + + for combo in combinations(subset, k): + candidate_subset = [t for t in subset if t not in combo] + score, _ = self._subset_err(psi, target, candidate_subset, squared_y) + if score > best_score or ( + np.isclose(score, best_score) + and (best_combo is None or combo < best_combo) + ): + best_score = score + best_combo = combo + + return list(best_combo) if best_combo is not None else [] + + def _select_most_significant_subset( + self, + psi: np.ndarray, + target: np.ndarray, + base_subset: List[int], + available: List[int], + count: int, + squared_y: float, + ) -> List[int]: + """Floating forward search (OSF-style) to pick ``count`` terms. + + This mirrors the bottom-up floating strategy but constrains the search + to adding terms on top of a fixed ``base_subset``. Backtracking only + removes terms that were added in this routine, never those in + ``base_subset``. + """ + + if count <= 0 or not available: + return [] + + _, base_score_arr = self._subset_err(psi, target, base_subset, squared_y) + base_score = float(np.sum(base_score_arr)) + + best_by_size = {0: (base_score, [])} + selected: List[int] = [] + current_score = base_score + last_added: Optional[int] = None + + def backtrack( + selected_terms: List[int], + score: float, + last_added_term: Optional[int], + ) -> Tuple[List[int], float]: + flag_first_removal = 1 + while ( + len(base_subset) + len(selected_terms) > 2 and len(selected_terms) > 0 + ): + full_subset = base_subset + selected_terms + ls_idx, ls_score = self._best_removal( + psi, target, full_subset, squared_y + ) + # Do not remove any term that belongs to the fixed base subset. + if ls_idx in base_subset: + break + + prev_best_score = best_by_size.get( + len(selected_terms) - 1, (-np.inf, []) + )[0] + if (flag_first_removal == 1 and ls_idx == last_added_term) or ( + ls_score <= prev_best_score + ): + break + + selected_terms = [t for t in selected_terms if t != ls_idx] + score = ls_score + if ls_score > prev_best_score: + best_by_size[len(selected_terms)] = ( + ls_score, + selected_terms.copy(), + ) + + flag_first_removal = 0 + + return selected_terms, score + + while len(selected) < count and len(available) > 0: + ms_idx, _ = self._best_addition( + psi, target, base_subset + selected, available, squared_y + ) + if ms_idx is None: + break + + candidate_selected = selected + [ms_idx] + candidate_score, _ = self._subset_err( + psi, target, base_subset + candidate_selected, squared_y + ) + + stored_score, stored_subset = best_by_size.get( + len(candidate_selected), (-np.inf, []) + ) + + if candidate_score > stored_score: + selected = candidate_selected + current_score = candidate_score + best_by_size[len(selected)] = (current_score, selected.copy()) + last_added = ms_idx + else: + selected = stored_subset.copy() + current_score = stored_score + last_added = ms_idx + + available = [a for a in available if a not in selected] + selected, current_score = backtrack(selected, current_score, last_added) + + return selected + + def _select_least_significant_subset( + self, + psi: np.ndarray, + target: np.ndarray, + base_subset: List[int], + count: int, + squared_y: float, + ) -> List[int]: + """Sequential backward floating-style removal of ``count`` terms. + + Uses repeated evaluation of the removal that maximizes the resulting + criterion. Backtracking avoids undoing the first removal when it is the + most recent change, mirroring the OSF safeguard. + """ + + if count <= 0 or len(base_subset) == 0: + return [] + + best_by_size = { + len(base_subset): self._subset_err(psi, target, base_subset, squared_y) + } + removed: List[int] = [] + current_score = best_by_size[len(base_subset)][0] + last_removed: Optional[int] = None + + while len(removed) < count and (len(base_subset) - len(removed)) > 0: + working_subset = [t for t in base_subset if t not in removed] + ls_idx, _ = self._best_removal(psi, target, working_subset, squared_y) + candidate_removed = removed + [ls_idx] + candidate_subset = [t for t in base_subset if t not in candidate_removed] + candidate_score, _ = self._subset_err( + psi, target, candidate_subset, squared_y + ) + + stored_score, stored_removed = best_by_size.get( + len(candidate_subset), (-np.inf, []) + ) + + if candidate_score > stored_score: + removed = candidate_removed + current_score = candidate_score + best_by_size[len(candidate_subset)] = (current_score, removed.copy()) + last_removed = ls_idx + else: + removed = stored_removed.copy() + current_score = stored_score + last_removed = ls_idx + + # Backtrack: avoid immediately re-removing the last removed term. + flag_first_removal = 1 + while len(base_subset) - len(removed) > 2: + working_subset = [t for t in base_subset if t not in removed] + next_idx, next_score = self._best_removal( + psi, target, working_subset, squared_y + ) + prev_best_score = best_by_size.get( + len(working_subset) - 1, (-np.inf, []) + )[0] + if (flag_first_removal == 1 and next_idx == last_removed) or ( + next_score <= prev_best_score + ): + break + + removed.append(next_idx) + current_score = next_score + best_by_size[len(working_subset) - 1] = ( + current_score, + removed.copy(), + ) + flag_first_removal = 0 + + if len(removed) >= count: + break + + return removed + + def _backtrack( + self, + psi: np.ndarray, + target: np.ndarray, + subset: List[int], + current_score: float, + best_by_size: dict, + squared_y: float, + last_added: Optional[int], + ) -> Tuple[List[int], float]: + """Adaptive backward step used by OSF/OIF.""" + + flag_first_removal = 1 + while len(subset) > 2: + ls_idx, ls_score = self._best_removal(psi, target, subset, squared_y) + prev_best_score = best_by_size.get(len(subset) - 1, (-np.inf, []))[0] + if (flag_first_removal == 1 and ls_idx == last_added) or ( + ls_score <= prev_best_score + ): + break + + subset = [t for t in subset if t != ls_idx] + current_score = ls_score + if ls_score > prev_best_score: + best_by_size[len(subset)] = (ls_score, subset.copy()) + + flag_first_removal = 0 + + return subset, current_score + + +class OSF(_OrthogonalFloatingBase): + """Orthogonal Sequential Floating search (paper Section 3.2).""" + + def run_mss_algorithm( + self, psi: np.ndarray, y: np.ndarray, process_term_number: int + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + target = self._default_estimation_target(y) + squared_y = self._compute_squared_y(target) + + total_terms = psi.shape[1] + all_indices = list(range(total_terms)) + + best_by_size = {0: (0.0, [])} + subset: List[int] = [] + current_score = 0.0 + last_added: Optional[int] = None + + while len(subset) < process_term_number and len(subset) < total_terms: + available = [idx for idx in all_indices if idx not in subset] + if not available: + break + + ms_idx, _ = self._best_addition(psi, target, subset, available, squared_y) + if ms_idx is None: + break + + candidate_subset = subset + [ms_idx] + candidate_score, _ = self._subset_err( + psi, target, candidate_subset, squared_y + ) + + stored_score, stored_subset = best_by_size.get( + len(candidate_subset), (-np.inf, []) + ) + + if candidate_score > stored_score: + subset = candidate_subset + current_score = candidate_score + best_by_size[len(subset)] = (current_score, subset.copy()) + last_added = ms_idx + else: + subset = stored_subset.copy() + current_score = stored_score + last_added = ms_idx + + subset, current_score = self._backtrack( + psi, target, subset, current_score, best_by_size, squared_y, last_added + ) + + _, err_vals = self._subset_err(psi, target, subset, squared_y) + piv = np.array(subset, dtype=int) + psi_selected = psi[:, piv] if len(piv) else psi[:, :0] + return err_vals, piv, psi_selected, target + + +class OIF(OSF): + """Orthogonal Improved Floating search (paper Section 3.3).""" + + def run_mss_algorithm( + self, psi: np.ndarray, y: np.ndarray, process_term_number: int + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + target = self._default_estimation_target(y) + squared_y = self._compute_squared_y(target) + total_terms = psi.shape[1] + all_indices = list(range(total_terms)) + + best_by_size = {0: (0.0, [])} + subset: List[int] = [] + current_score = 0.0 + last_added: Optional[int] = None + + while len(subset) < process_term_number and len(subset) < total_terms: + available = [idx for idx in all_indices if idx not in subset] + if not available: + break + + ms_idx, _ = self._best_addition(psi, target, subset, available, squared_y) + if ms_idx is None: + break + + candidate_subset = subset + [ms_idx] + candidate_score, _ = self._subset_err( + psi, target, candidate_subset, squared_y + ) + + stored_score, stored_subset = best_by_size.get( + len(candidate_subset), (-np.inf, []) + ) + + if candidate_score > stored_score: + subset = candidate_subset + current_score = candidate_score + best_by_size[len(subset)] = (current_score, subset.copy()) + last_added = ms_idx + else: + subset = stored_subset.copy() + current_score = stored_score + last_added = ms_idx + + subset, current_score = self._backtrack( + psi, target, subset, current_score, best_by_size, squared_y, last_added + ) + + # Swapping step: replace one weak term by the most significant + # available term (Definition 3 based swap). + subset, current_score, swap_added = self._swap_step( + psi, + target, + subset, + current_score, + best_by_size, + all_indices, + squared_y, + ) + + if swap_added is not None: + subset, current_score = self._backtrack( + psi, + target, + subset, + current_score, + best_by_size, + squared_y, + swap_added, + ) + + _, err_vals = self._subset_err(psi, target, subset, squared_y) + piv = np.array(subset, dtype=int) + psi_selected = psi[:, piv] if len(piv) else psi[:, :0] + return err_vals, piv, psi_selected, target + + def _swap_step( + self, + psi: np.ndarray, + target: np.ndarray, + subset: List[int], + current_score: float, + best_by_size: dict, + all_indices: List[int], + squared_y: float, + ) -> Tuple[List[int], float, Optional[int]]: + best_subset = subset.copy() + best_score = current_score + best_added: Optional[int] = None + + for idx in subset: + reduced = [t for t in subset if t != idx] + available = [i for i in all_indices if i not in reduced] + ms_idx, _ = self._best_addition(psi, target, reduced, available, squared_y) + if ms_idx is None or ms_idx in reduced: + continue + + candidate_subset = reduced + [ms_idx] + candidate_score, _ = self._subset_err( + psi, target, candidate_subset, squared_y + ) + + if candidate_score > best_score: + best_score = candidate_score + best_subset = candidate_subset + best_added = ms_idx + + if best_score > current_score: + best_by_size[len(best_subset)] = (best_score, best_subset.copy()) + return best_subset, best_score, best_added + + return subset, current_score, None + + +class OOS(_OrthogonalFloatingBase): + """Orthogonal Oscillating Search (paper Section 3.4). + + This class is named ``OOS`` (Orthogonal Oscillating Search) to avoid + the caret notation ``O^2S`` in code. It corresponds to the same method + described as O²S in the paper. + """ + + def __init__( + self, + *, + ylag: Union[int, List[int]] = 2, + xlag: Union[int, List[int]] = 2, + elag: Union[int, List[int]] = 2, + order_selection: bool = True, + info_criteria: str = "aic", + n_terms: Optional[int] = None, + n_info_values: int = 15, + estimator: Estimators = RecursiveLeastSquares(), + basis_function: Union[Polynomial, Fourier] = Polynomial(), + model_type: str = "NARMAX", + eps: float = np.finfo(np.float64).eps, + alpha: float = 0.0, + err_tol: Optional[float] = None, + apress_lambda: float = 1.0, + max_search_depth: Optional[int] = None, + ): + self.max_search_depth = max_search_depth + super().__init__( + ylag=ylag, + xlag=xlag, + elag=elag, + order_selection=order_selection, + info_criteria=info_criteria, + n_terms=n_terms, + n_info_values=n_info_values, + estimator=estimator, + basis_function=basis_function, + model_type=model_type, + eps=eps, + alpha=alpha, + err_tol=err_tol, + apress_lambda=apress_lambda, + ) + self._validate_oos_params() + + def _validate_oos_params(self) -> None: + if self.max_search_depth is None: + return + if not isinstance(self.max_search_depth, int) or self.max_search_depth < 1: + raise ValueError( + f"max_search_depth must be integer and > zero. Got {self.max_search_depth}" + ) + + def _resolve_search_depth(self, process_term_number: int, total_terms: int) -> int: + """Choose search depth per OFSA guideline (25% of the smaller side).""" + + if self.max_search_depth is not None: + return self.max_search_depth + + smaller_side = max( + 1, min(process_term_number, max(0, total_terms - process_term_number)) + ) + depth = int(np.floor(0.25 * smaller_side)) + return max(1, depth) + + def run_mss_algorithm( + self, psi: np.ndarray, y: np.ndarray, process_term_number: int + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + target = self._default_estimation_target(y) + squared_y = self._compute_squared_y(target) + total_terms = psi.shape[1] + all_indices = list(range(total_terms)) + + # Resolve depth once we know xi and n, as suggested by the paper. + max_depth = self._resolve_search_depth(process_term_number, total_terms) + + # Initial model: greedy inclusion of ``process_term_number`` terms. + subset: List[int] = [] + available = all_indices.copy() + for _ in range(min(process_term_number, total_terms)): + ms_idx, _ = self._best_addition(psi, target, subset, available, squared_y) + if ms_idx is None: + break + subset.append(ms_idx) + available.remove(ms_idx) + + current_score, _ = self._subset_err(psi, target, subset, squared_y) + + o = 1 + # Flags f1/f2 track consecutive failures of down/up swings as in Alg. 2. + f1 = 0 + f2 = 0 + + while o <= max_depth and len(subset) > 0: + improvement = False + + # Down swing: remove exactly o least significant, then add o most significant. + if len(subset) >= o: + down_subset = subset.copy() + to_remove = self._select_least_significant_subset( + psi, target, down_subset, o, squared_y + ) + + if len(to_remove) == o: + down_subset = [t for t in down_subset if t not in to_remove] + + available_down = [ + idx for idx in all_indices if idx not in down_subset + ] + if len(available_down) >= o: + ms_terms = self._select_most_significant_subset( + psi, + target, + down_subset, + available_down, + o, + squared_y, + ) + else: + ms_terms = [] + + if len(ms_terms) == o: + down_subset = down_subset + ms_terms + down_score, _ = self._subset_err( + psi, target, down_subset, squared_y + ) + + if down_score > current_score: + subset = down_subset + current_score = down_score + improvement = True + f1 = 0 + else: + f1 = 1 + else: + f1 = 1 + else: + f1 = 1 + else: + f1 = 1 + + # If both down and previous up swings failed, increase depth before the up swing. + if f1 == 1 and f2 == 1: + o += 1 + f1 = 0 + f2 = 0 + if o > max_depth: + break + + # Up swing: add o most significant, then remove o least significant. + if len(subset) + o <= total_terms: + up_subset = subset.copy() + available_up = [idx for idx in all_indices if idx not in up_subset] + if len(available_up) >= o: + ms_terms_up = self._select_most_significant_subset( + psi, + target, + up_subset, + available_up, + o, + squared_y, + ) + else: + ms_terms_up = [] + + if len(ms_terms_up) == o: + up_subset = up_subset + ms_terms_up + + to_remove_up = self._select_least_significant_subset( + psi, target, up_subset, o, squared_y + ) + if len(to_remove_up) == o: + up_subset = [t for t in up_subset if t not in to_remove_up] + up_score, _ = self._subset_err( + psi, target, up_subset, squared_y + ) + + if up_score > current_score: + subset = up_subset + current_score = up_score + improvement = True + f2 = 0 + else: + f2 = 1 + else: + f2 = 1 + else: + f2 = 1 + else: + f2 = 1 + + if improvement: + o = 1 + f1 = 0 + f2 = 0 + else: + if f1 == 1 and f2 == 1: + o += 1 + f1 = 0 + f2 = 0 + else: + # Alternate swings but keep depth. + pass + + _, err_vals = self._subset_err(psi, target, subset, squared_y) + piv = np.array(subset, dtype=int) + psi_selected = psi[:, piv] if len(piv) else psi[:, :0] + return err_vals, piv, psi_selected, target + + +# Alias matching the notation O²S used in the paper. +O2S = OOS + +__all__ = ["OSF", "OIF", "OOS", "O2S"] diff --git a/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py b/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py new file mode 100644 index 00000000..5358c28c --- /dev/null +++ b/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py @@ -0,0 +1,574 @@ +import numpy as np +import pytest +from numpy.testing import assert_equal + +from sysidentpy.basis_function import Polynomial +from sysidentpy.model_structure_selection import OIF, OOS, OSF +from sysidentpy.parameter_estimation.estimators import LeastSquares +from sysidentpy.tests.test_narmax_base import create_test_data + +x, y, _ = create_test_data() +train_percentage = 90 +split_data = int(len(x) * (train_percentage / 100)) + +X_train = np.reshape(x[0:split_data, 0], (-1, 1)) +X_test = np.reshape(x[split_data::, 0], (-1, 1)) +y_train = np.reshape(y[0:split_data, 0], (-1, 1)) +y_test = np.reshape(y[split_data::, 0], (-1, 1)) + + +def _fit_and_predict(model_cls): + model = model_cls( + n_terms=4, + order_selection=False, + ylag=[1, 2], + xlag=2, + basis_function=Polynomial(degree=2), + estimator=LeastSquares(), + ) + model.fit(X=X_train, y=y_train) + yhat = model.predict(X=X_test, y=y_test) + assert_equal(model.final_model.shape[0], model.n_terms) + assert_equal(yhat.shape, y_test.shape) + + +def test_osf_runs_and_predicts(): + _fit_and_predict(OSF) + + +def test_oif_runs_and_predicts(): + _fit_and_predict(OIF) + + +def test_oos_runs_and_predicts(): + _fit_and_predict(OOS) + + +# --- Unit-level coverage for helper routines --- + + +def _make_base(): + model = OSF( + n_terms=3, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + ) + psi = np.eye(3) + target = np.array([[1.0], [0.0], [0.0]]) + sqy = model._compute_squared_y(target) + return model, psi, target, sqy + + +def test_subset_err_empty_and_nonempty(): + model, psi, target, sqy = _make_base() + score_empty, err_empty = model._subset_err(psi, target, [], sqy) + assert_equal(score_empty, 0.0) + assert_equal(err_empty.shape[0], 0) + + score_full, err_full = model._subset_err(psi, target, [0, 1, 2], sqy) + assert_equal(score_full, 1.0) + assert_equal(err_full.tolist(), [1.0, 0.0, 0.0]) + + +def test_best_addition_and_removal_ties(): + model, psi, target, sqy = _make_base() + # tie on addition: target = [1,1,0] + target = np.array([[1.0], [1.0], [0.0]]) + sqy = model._compute_squared_y(target) + add_idx, _ = model._best_addition(psi, target, [], [0, 1], sqy) + assert_equal(add_idx, 0) + + # tie on removal prefers lower index + rm_idx, _ = model._best_removal(psi, target, [0, 1], sqy) + assert_equal(rm_idx, 0) + + +def test_most_and_least_significant_subsets_exhaustive(): + model, psi, target, sqy = _make_base() + target = np.array([[1.0], [0.0], [1.0]]) + sqy = model._compute_squared_y(target) + + ms = model._most_significant_terms(psi, target, [], [0, 1, 2], 2, sqy) + assert_equal(ms, [0, 2]) + + ls = model._least_significant_terms(psi, target, [0, 1, 2], 2, sqy) + assert_equal(ls, [0, 1]) + + # zero-count shortcut branches + assert_equal(model._most_significant_terms(psi, target, [], [0, 1], 0, sqy), []) + assert_equal(model._least_significant_terms(psi, target, [0, 1], 0, sqy), []) + + +def test_backtrack_removes_non_last_added(): + model, psi, target, sqy = _make_base() + subset = [0, 1, 2] + best_by_size = {2: (-np.inf, [])} + last_added = 2 + updated, score = model._backtrack( + psi, target, subset, 0.0, best_by_size, sqy, last_added + ) + assert_equal(updated, [0, 2]) + assert_equal(score, 1.0) + + +def test_select_most_significant_subset_and_least_paths(): + model, psi, target, sqy = _make_base() + psi = np.eye(4) + target = np.array([[1.0], [0.5], [0.0], [0.0]]) + sqy = model._compute_squared_y(target) + + # count=0 early exit + assert_equal( + model._select_most_significant_subset(psi, target, [], [0, 1, 2], 0, sqy), [] + ) + + # main path with backtrack + selection = model._select_most_significant_subset( + psi, target, [0, 1], [2, 3], 2, sqy + ) + assert len(selection) <= 2 + + # least-significant subset with backtracking branch + removed = model._select_least_significant_subset(psi, target, [0, 1, 2, 3], 1, sqy) + assert len(removed) >= 1 + + +def test_select_least_significant_subset_with_backtracking(): + model, psi, target, sqy = _make_base() + psi = np.eye(4) + target = np.array([[1.0], [0.0], [0.0], [0.0]]) + sqy = model._compute_squared_y(target) + removed = model._select_least_significant_subset(psi, target, [0, 1, 2, 3], 2, sqy) + assert_equal(removed, [1, 2]) + + +def test_swap_step_improves_and_nochange(): + model, psi, target, sqy = _make_base() + all_indices = [0, 1, 2] + + # improvement case + subset = [1, 2] + current_score, _ = model._subset_err(psi, target, subset, sqy) + best_by_size = {len(subset): (current_score, subset.copy())} + new_subset, new_score, added = OIF()._swap_step( + psi, target, subset, current_score, best_by_size, all_indices, sqy + ) + assert new_score > current_score + assert_equal(sorted(new_subset), [0, 2]) + assert_equal(added, 0) + + # no improvement case + subset = [0, 1] + current_score, _ = model._subset_err(psi, target, subset, sqy) + best_by_size = {len(subset): (current_score, subset.copy())} + same_subset, same_score, added_none = OIF()._swap_step( + psi, target, subset, current_score, best_by_size, all_indices, sqy + ) + assert_equal(same_subset, subset) + assert_equal(same_score, current_score) + assert added_none is None + + +def test_oos_no_improvement_increments_depth_and_validation(): + # max_search_depth validation + try: + OOS(max_search_depth=0) + assert False, "Expected ValueError" + except ValueError: + pass + + model = OOS( + n_terms=1, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + max_search_depth=1, + ) + psi = np.eye(2) + target = np.array([[0.0], [0.0], [0.0]]) # aligned so target after lag has 2 rows + err, piv, psi_sel, tgt = model.run_mss_algorithm(psi, target, 1) + assert_equal(err.shape[0], len(piv)) + assert_equal(piv.tolist(), [0]) + assert_equal(psi_sel.shape[1], 1) + + +def test_osf_handles_insufficient_available_terms(): + model = OSF( + n_terms=5, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + ) + psi = np.ones((1, 1)) + target = np.array([[1.0], [1.0]]) # after lag alignment -> shape (1,1) + err, piv, psi_sel, tgt = model.run_mss_algorithm(psi, target, 5) + assert_equal(piv.tolist(), [0]) + + +# --- Additional coverage helpers --- + + +def test_select_most_significant_subset_breaks_on_base_removal(monkeypatch): + model, psi, target, sqy = _make_base() + + monkeypatch.setattr( + model, + "_best_addition", + lambda *args, **kwargs: (args[3][0] if args[3] else None, 0.0), + ) + monkeypatch.setattr( + model, + "_subset_err", + lambda *args, **kwargs: (0.0, np.zeros(len(args[2]))), + ) + monkeypatch.setattr(model, "_best_removal", lambda *args, **kwargs: (0, 0.0)) + + selection = model._select_most_significant_subset(psi, target, [0, 1], [2], 1, sqy) + assert_equal(selection, [2]) + + +def test_select_most_significant_subset_removal_and_stored_subset(monkeypatch): + model, psi, target, _ = _make_base() + + order = iter([0, 1, 2, 3, None]) + + def fake_best_addition(*args, **kwargs): + idx = next(order) + return (idx, 0.0) if idx is not None else (None, 0.0) + + monkeypatch.setattr(model, "_best_addition", fake_best_addition) + monkeypatch.setattr( + model, + "_subset_err", + lambda *args, **kwargs: (0.0, np.zeros(len(args[2]))), + ) + monkeypatch.setattr( + model, + "_best_removal", + lambda psi, target, subset, sqy: (subset[0] if subset else 0, 1.0), + ) + + selection = model._select_most_significant_subset( + np.zeros((1, 4)), target, [], [0, 1, 2, 3], 3, 1.0 + ) + assert len(selection) <= 3 + + +def test_select_least_significant_subset_early_exit(): + model, psi, target, sqy = _make_base() + removed = model._select_least_significant_subset(psi, target, [], 0, sqy) + assert_equal(removed, []) + + +def test_select_least_significant_subset_else_and_backtrack(monkeypatch): + model, psi, target, _ = _make_base() + base_subset = [0, 1, 2] + + class StopSearch(Exception): + pass + + removal_calls = {"count": 0} + + def fake_subset_err(*args, **kwargs): + return -np.inf, np.zeros(len(args[2])) + + def fake_best_removal(psi_arr, tgt, subset, sqy): + removal_calls["count"] += 1 + if removal_calls["count"] > 2: + raise StopSearch + return subset[0] if subset else 0, -np.inf + + monkeypatch.setattr(model, "_subset_err", fake_subset_err) + monkeypatch.setattr(model, "_best_removal", fake_best_removal) + + with pytest.raises(StopSearch): + model._select_least_significant_subset(psi, target, base_subset, 2, 1.0) + + +def test_osf_run_mss_respects_stored_subset(monkeypatch): + model, _, _, _ = _make_base() + + add_order = iter([0, None]) + + def fake_best_addition(*args, **kwargs): + idx = next(add_order, None) + return (idx, 0.0) if idx is not None else (None, 0.0) + + monkeypatch.setattr(model, "_best_addition", fake_best_addition) + monkeypatch.setattr( + model, + "_subset_err", + lambda *args, **kwargs: (0.0, np.zeros(len(args[2]))), + ) + monkeypatch.setattr( + model, + "_backtrack", + lambda psi, target, subset, current_score, best_by_size, squared_y, last_added: ( + subset[:-1], + current_score, + ), + ) + + psi = np.ones((1, 1)) + y = np.ones((1, 1)) + err, piv, psi_sel, tgt = model.run_mss_algorithm(psi, y, 2) + assert piv.size >= 0 + assert_equal(err.shape[0], psi_sel.shape[1]) + + +def test_osf_breaks_when_available_empty(monkeypatch): + model, psi, target, _ = _make_base() + + import sysidentpy.model_structure_selection.orthogonal_floating_search as ofs + + monkeypatch.setattr(ofs, "range", lambda *args, **kwargs: [], raising=False) + + err, piv, _, _ = model.run_mss_algorithm(psi[:, :1], target[:1], 1) + assert_equal(piv.tolist(), []) + assert_equal(err.shape[0], 0) + + +def test_osf_candidate_score_not_improving(monkeypatch): + model = OSF( + n_terms=2, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + ) + + add_order = iter([0, 1, None]) + + def fake_best_addition(*args, **kwargs): + idx = next(add_order, None) + return (idx, 0.0) if idx is not None else (None, 0.0) + + monkeypatch.setattr(model, "_best_addition", fake_best_addition) + monkeypatch.setattr( + model, + "_subset_err", + lambda *args, **kwargs: (0.0, np.zeros(len(args[2]))), + ) + monkeypatch.setattr( + model, + "_backtrack", + lambda psi, target, subset, current_score, best_by_size, squared_y, last_added: ( + [], + current_score, + ), + ) + + psi = np.ones((1, 2)) + y = np.ones((1, 1)) + err, piv, _, _ = model.run_mss_algorithm(psi, y, 2) + assert piv.size >= 0 + assert_equal(err.shape[0], piv.shape[0]) + + +def test_oif_handles_none_addition_and_else_branch(monkeypatch): + model = OIF( + n_terms=2, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + ) + + add_order = iter([0, None]) + + def fake_best_addition_oif(*args, **kwargs): + idx = next(add_order, None) + return (idx, 0.0) if idx is not None else (None, 0.0) + + monkeypatch.setattr(model, "_best_addition", fake_best_addition_oif) + monkeypatch.setattr( + model, + "_subset_err", + lambda *args, **kwargs: (0.0, np.zeros(len(args[2]))), + ) + monkeypatch.setattr( + model, + "_backtrack", + lambda psi, target, subset, current_score, best_by_size, squared_y, last_added: ( + subset[:-1], + current_score, + ), + ) + + psi = np.ones((1, 1)) + y = np.ones((1, 1)) + err, piv, psi_sel, _ = model.run_mss_algorithm(psi, y, 2) + assert piv.size >= 0 + assert_equal(psi_sel.shape[1], piv.shape[0]) + + +def test_oif_swap_step_skips_none(monkeypatch): + model, psi, target, sqy = _make_base() + oif = OIF() + monkeypatch.setattr( + oif, + "_best_addition", + lambda *args, **kwargs: (None, 0.0), + ) + subset, score, added = oif._swap_step( + psi, target, [0, 1], 0.0, {2: (0.0, [0, 1])}, [0, 1, 2], sqy + ) + assert_equal(subset, [0, 1]) + assert_equal(score, 0.0) + assert added is None + + +def test_oif_breaks_when_available_empty(monkeypatch): + model, psi, target, _ = _make_base() + + import sysidentpy.model_structure_selection.orthogonal_floating_search as ofs + + monkeypatch.setattr(ofs, "range", lambda *args, **kwargs: [], raising=False) + + err, piv, _, _ = model.run_mss_algorithm(psi[:, :1], target[:1], 1) + assert_equal(piv.tolist(), []) + assert_equal(err.shape[0], 0) + + +def test_oif_candidate_score_not_improving(monkeypatch): + model = OIF( + n_terms=2, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + ) + + add_order = iter([0, 1, None]) + + def fake_best_addition_oif_candidate(*args, **kwargs): + idx = next(add_order, None) + return (idx, 0.0) if idx is not None else (None, 0.0) + + monkeypatch.setattr(model, "_best_addition", fake_best_addition_oif_candidate) + monkeypatch.setattr( + model, + "_subset_err", + lambda *args, **kwargs: (0.0, np.zeros(len(args[2]))), + ) + monkeypatch.setattr( + model, + "_backtrack", + lambda psi, target, subset, current_score, best_by_size, squared_y, last_added: ( + [], + current_score, + ), + ) + + psi = np.ones((1, 2)) + y = np.ones((1, 1)) + err, piv, _, _ = model.run_mss_algorithm(psi, y, 2) + assert piv.size >= 0 + assert_equal(err.shape[0], piv.shape[0]) + + +def test_select_most_significant_subset_none_addition(monkeypatch): + model, psi, target, sqy = _make_base() + monkeypatch.setattr(model, "_best_addition", lambda *args, **kwargs: (None, 0.0)) + result = model._select_most_significant_subset(psi, target, [], [0, 1], 2, sqy) + assert result == [] + + +def test_oif_handles_empty_available(monkeypatch): + model = OIF( + n_terms=1, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + ) + psi = np.ones((1, 1)) + y = np.zeros((1, 1)) + import sysidentpy.model_structure_selection.orthogonal_floating_search as ofs + + monkeypatch.setattr(ofs, "range", lambda *args, **kwargs: [], raising=False) + + err, piv, psi_sel, _ = model.run_mss_algorithm(psi, y, 1) + assert err.size == 0 + assert piv.size == 0 + assert psi_sel.shape[1] == 0 + + +def test_oos_handles_none_greedy_addition(monkeypatch): + model = OOS( + n_terms=1, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + max_search_depth=1, + ) + + monkeypatch.setattr( + model, + "_best_addition", + lambda *args, **kwargs: (None, 0.0), + ) + + psi = np.ones((1, 1)) + y = np.ones((1, 1)) + err, piv, psi_sel, _ = model.run_mss_algorithm(psi, y, 1) + assert_equal(piv.tolist(), []) + assert_equal(err.shape[0], 0) + assert_equal(psi_sel.shape[1], 0) + + +def test_oos_down_and_up_swings_improve(monkeypatch): + model = OOS( + n_terms=2, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + max_search_depth=1, + ) + + # Score favors presence of term 2 > term 1 > others + def score_subset(*args, **kwargs): + subset = args[2] + if 2 in subset: + score = 3.0 + elif 1 in subset: + score = 2.0 + else: + score = float(len(subset)) + return score, np.zeros(len(subset)) + + add_order = iter([0, 1, 2]) + + def fake_best_addition_oos(*args, **kwargs): + idx = next(add_order, None) + return (idx, 0.0) if idx is not None else (None, 0.0) + + monkeypatch.setattr(model, "_best_addition", fake_best_addition_oos) + monkeypatch.setattr(model, "_subset_err", score_subset) + monkeypatch.setattr(model, "_least_significant_terms", lambda *args, **kwargs: []) + + def fake_most_significant_terms(psi, target, subset, available, count, sqy): + return [a for a in available if a not in subset][:count] + + monkeypatch.setattr(model, "_most_significant_terms", fake_most_significant_terms) + + psi = np.eye(3) + y = np.ones((3, 1)) + err, piv, psi_sel, _ = model.run_mss_algorithm(psi, y, 1) + assert err.size >= 0 + assert piv.size >= 0 From ae8958d06372e4ddbeec241af7473b6786ca27bf Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Mon, 8 Dec 2025 22:07:14 -0300 Subject: [PATCH 07/10] refine orthogonal floating search logic and add coverage --- .../orthogonal_floating_search.py | 468 ++++++++++-------- .../tests/test_orthogonal_floating_search.py | 136 +++++ 2 files changed, 392 insertions(+), 212 deletions(-) diff --git a/sysidentpy/model_structure_selection/orthogonal_floating_search.py b/sysidentpy/model_structure_selection/orthogonal_floating_search.py index 6bb354a4..2c726593 100644 --- a/sysidentpy/model_structure_selection/orthogonal_floating_search.py +++ b/sysidentpy/model_structure_selection/orthogonal_floating_search.py @@ -11,13 +11,12 @@ from __future__ import annotations -from typing import List, Optional, Sequence, Tuple, Union +from typing import Dict, List, Optional, Tuple, Union from itertools import combinations import numpy as np from ..basis_function import Fourier, Polynomial -from ..narmax_base import house, rowhouse from ..parameter_estimation.estimators import RecursiveLeastSquares from .ofr_base import Estimators, OFRBase, _compute_err_slice @@ -76,15 +75,20 @@ def _subset_err( """ if not subset: - return 0.0, np.array([]) + return 0.0, np.array([], dtype=float) psi_sel = psi[:, subset] + if psi_sel.size == 0: + return 0.0, np.array([], dtype=float) + # Reduced QR gives orthonormal columns (||w_i||=1), aligning with # the Gram-Schmidt-based ERR definition without explicit scaling. q, _ = np.linalg.qr(psi_sel, mode="reduced") g = q.T @ target - denom = squared_y if squared_y > 0 else np.finfo(np.float64).eps - err_vals = np.square(g).flatten() / denom + + err_vals = np.zeros(len(subset), dtype=float) + mapped = g.shape[0] + err_vals[:mapped] = np.square(g).flatten() / squared_y score = float(np.sum(err_vals)) return score, err_vals @@ -216,7 +220,7 @@ def _select_most_significant_subset( _, base_score_arr = self._subset_err(psi, target, base_subset, squared_y) base_score = float(np.sum(base_score_arr)) - best_by_size = {0: (base_score, [])} + best_by_size: Dict[int, Tuple[float, Tuple[int, ...]]] = {0: (base_score, ())} selected: List[int] = [] current_score = base_score last_added: Optional[int] = None @@ -239,7 +243,7 @@ def backtrack( break prev_best_score = best_by_size.get( - len(selected_terms) - 1, (-np.inf, []) + len(selected_terms) - 1, (-np.inf, ()) )[0] if (flag_first_removal == 1 and ls_idx == last_added_term) or ( ls_score <= prev_best_score @@ -251,7 +255,7 @@ def backtrack( if ls_score > prev_best_score: best_by_size[len(selected_terms)] = ( ls_score, - selected_terms.copy(), + tuple(selected_terms), ) flag_first_removal = 0 @@ -271,16 +275,16 @@ def backtrack( ) stored_score, stored_subset = best_by_size.get( - len(candidate_selected), (-np.inf, []) + len(candidate_selected), (-np.inf, ()) ) if candidate_score > stored_score: selected = candidate_selected current_score = candidate_score - best_by_size[len(selected)] = (current_score, selected.copy()) + best_by_size[len(selected)] = (current_score, tuple(selected)) last_added = ms_idx else: - selected = stored_subset.copy() + selected = list(stored_subset) current_score = stored_score last_added = ms_idx @@ -307,11 +311,12 @@ def _select_least_significant_subset( if count <= 0 or len(base_subset) == 0: return [] - best_by_size = { - len(base_subset): self._subset_err(psi, target, base_subset, squared_y) + base_score, _ = self._subset_err(psi, target, base_subset, squared_y) + best_by_size: Dict[int, Tuple[float, Tuple[int, ...]]] = { + len(base_subset): (base_score, tuple(base_subset)) } removed: List[int] = [] - current_score = best_by_size[len(base_subset)][0] + current_score = base_score last_removed: Optional[int] = None while len(removed) < count and (len(base_subset) - len(removed)) > 0: @@ -324,16 +329,19 @@ def _select_least_significant_subset( ) stored_score, stored_removed = best_by_size.get( - len(candidate_subset), (-np.inf, []) + len(candidate_subset), (-np.inf, ()) ) if candidate_score > stored_score: removed = candidate_removed current_score = candidate_score - best_by_size[len(candidate_subset)] = (current_score, removed.copy()) + best_by_size[len(candidate_subset)] = ( + current_score, + tuple(removed), + ) last_removed = ls_idx else: - removed = stored_removed.copy() + removed = list(stored_removed) current_score = stored_score last_removed = ls_idx @@ -345,7 +353,7 @@ def _select_least_significant_subset( psi, target, working_subset, squared_y ) prev_best_score = best_by_size.get( - len(working_subset) - 1, (-np.inf, []) + len(working_subset) - 1, (-np.inf, ()) )[0] if (flag_first_removal == 1 and next_idx == last_removed) or ( next_score <= prev_best_score @@ -356,7 +364,7 @@ def _select_least_significant_subset( current_score = next_score best_by_size[len(working_subset) - 1] = ( current_score, - removed.copy(), + tuple(removed), ) flag_first_removal = 0 @@ -371,7 +379,7 @@ def _backtrack( target: np.ndarray, subset: List[int], current_score: float, - best_by_size: dict, + best_by_size: Dict[int, Tuple[float, Tuple[int, ...]]], squared_y: float, last_added: Optional[int], ) -> Tuple[List[int], float]: @@ -380,7 +388,7 @@ def _backtrack( flag_first_removal = 1 while len(subset) > 2: ls_idx, ls_score = self._best_removal(psi, target, subset, squared_y) - prev_best_score = best_by_size.get(len(subset) - 1, (-np.inf, []))[0] + prev_best_score = best_by_size.get(len(subset) - 1, (-np.inf, ()))[0] if (flag_first_removal == 1 and ls_idx == last_added) or ( ls_score <= prev_best_score ): @@ -389,80 +397,26 @@ def _backtrack( subset = [t for t in subset if t != ls_idx] current_score = ls_score if ls_score > prev_best_score: - best_by_size[len(subset)] = (ls_score, subset.copy()) + best_by_size[len(subset)] = (ls_score, tuple(subset)) flag_first_removal = 0 return subset, current_score + def _floating_forward_search( + self, + psi: np.ndarray, + target: np.ndarray, + process_term_number: int, + squared_y: float, + swap_callback=None, + ) -> List[int]: + """Shared floating forward search used by OSF and OIF.""" -class OSF(_OrthogonalFloatingBase): - """Orthogonal Sequential Floating search (paper Section 3.2).""" - - def run_mss_algorithm( - self, psi: np.ndarray, y: np.ndarray, process_term_number: int - ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: - target = self._default_estimation_target(y) - squared_y = self._compute_squared_y(target) - - total_terms = psi.shape[1] - all_indices = list(range(total_terms)) - - best_by_size = {0: (0.0, [])} - subset: List[int] = [] - current_score = 0.0 - last_added: Optional[int] = None - - while len(subset) < process_term_number and len(subset) < total_terms: - available = [idx for idx in all_indices if idx not in subset] - if not available: - break - - ms_idx, _ = self._best_addition(psi, target, subset, available, squared_y) - if ms_idx is None: - break - - candidate_subset = subset + [ms_idx] - candidate_score, _ = self._subset_err( - psi, target, candidate_subset, squared_y - ) - - stored_score, stored_subset = best_by_size.get( - len(candidate_subset), (-np.inf, []) - ) - - if candidate_score > stored_score: - subset = candidate_subset - current_score = candidate_score - best_by_size[len(subset)] = (current_score, subset.copy()) - last_added = ms_idx - else: - subset = stored_subset.copy() - current_score = stored_score - last_added = ms_idx - - subset, current_score = self._backtrack( - psi, target, subset, current_score, best_by_size, squared_y, last_added - ) - - _, err_vals = self._subset_err(psi, target, subset, squared_y) - piv = np.array(subset, dtype=int) - psi_selected = psi[:, piv] if len(piv) else psi[:, :0] - return err_vals, piv, psi_selected, target - - -class OIF(OSF): - """Orthogonal Improved Floating search (paper Section 3.3).""" - - def run_mss_algorithm( - self, psi: np.ndarray, y: np.ndarray, process_term_number: int - ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: - target = self._default_estimation_target(y) - squared_y = self._compute_squared_y(target) total_terms = psi.shape[1] all_indices = list(range(total_terms)) - best_by_size = {0: (0.0, [])} + best_by_size: Dict[int, Tuple[float, Tuple[int, ...]]] = {0: (0.0, ())} subset: List[int] = [] current_score = 0.0 last_added: Optional[int] = None @@ -482,45 +436,97 @@ def run_mss_algorithm( ) stored_score, stored_subset = best_by_size.get( - len(candidate_subset), (-np.inf, []) + len(candidate_subset), (-np.inf, ()) ) if candidate_score > stored_score: subset = candidate_subset current_score = candidate_score - best_by_size[len(subset)] = (current_score, subset.copy()) + best_by_size[len(subset)] = (current_score, tuple(subset)) last_added = ms_idx else: - subset = stored_subset.copy() + subset = list(stored_subset) current_score = stored_score last_added = ms_idx subset, current_score = self._backtrack( - psi, target, subset, current_score, best_by_size, squared_y, last_added - ) - - # Swapping step: replace one weak term by the most significant - # available term (Definition 3 based swap). - subset, current_score, swap_added = self._swap_step( psi, target, subset, current_score, best_by_size, - all_indices, squared_y, + last_added, ) - if swap_added is not None: - subset, current_score = self._backtrack( + if swap_callback is not None: + subset, current_score, swap_added = swap_callback( psi, target, subset, current_score, best_by_size, + all_indices, squared_y, - swap_added, ) + if swap_added is not None: + subset, current_score = self._backtrack( + psi, + target, + subset, + current_score, + best_by_size, + squared_y, + swap_added, + ) + + return subset + + +class OSF(_OrthogonalFloatingBase): + """Orthogonal Sequential Floating search (paper Section 3.2). + + Iteratively adds and conditionally removes regressors based on the ERR + criterion. Preserves API compatibility with other model structure selection + classes; the constructor mirrors ``OFRBase`` arguments. + """ + + def run_mss_algorithm( + self, psi: np.ndarray, y: np.ndarray, process_term_number: int + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Execute the OSF search and return ERR values and selected pivots.""" + target = self._default_estimation_target(y) + squared_y = self._compute_squared_y(target) + subset = self._floating_forward_search( + psi, target, process_term_number, squared_y + ) + + _, err_vals = self._subset_err(psi, target, subset, squared_y) + piv = np.array(subset, dtype=int) + psi_selected = psi[:, piv] if len(piv) else psi[:, :0] + return err_vals, piv, psi_selected, target + + +class OIF(OSF): + """Orthogonal Improved Floating search (paper Section 3.3). + + Extends ``OSF`` with a swapping step that replaces weak terms with more + significant candidates when it improves the ERR score. + """ + + def run_mss_algorithm( + self, psi: np.ndarray, y: np.ndarray, process_term_number: int + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Execute the OIF search and return ERR values and selected pivots.""" + target = self._default_estimation_target(y) + squared_y = self._compute_squared_y(target) + subset = self._floating_forward_search( + psi, + target, + process_term_number, + squared_y, + swap_callback=self._swap_step, + ) _, err_vals = self._subset_err(psi, target, subset, squared_y) piv = np.array(subset, dtype=int) @@ -533,7 +539,7 @@ def _swap_step( target: np.ndarray, subset: List[int], current_score: float, - best_by_size: dict, + best_by_size: Dict[int, Tuple[float, Tuple[int, ...]]], all_indices: List[int], squared_y: float, ) -> Tuple[List[int], float, Optional[int]]: @@ -559,7 +565,7 @@ def _swap_step( best_added = ms_idx if best_score > current_score: - best_by_size[len(best_subset)] = (best_score, best_subset.copy()) + best_by_size[len(best_subset)] = (best_score, tuple(best_subset)) return best_subset, best_score, best_added return subset, current_score, None @@ -616,7 +622,8 @@ def _validate_oos_params(self) -> None: return if not isinstance(self.max_search_depth, int) or self.max_search_depth < 1: raise ValueError( - f"max_search_depth must be integer and > zero. Got {self.max_search_depth}" + "max_search_depth must be a positive int or None; " + f"got {self.max_search_depth!r} (type={type(self.max_search_depth).__name__})" ) def _resolve_search_depth(self, process_term_number: int, total_terms: int) -> int: @@ -631,144 +638,181 @@ def _resolve_search_depth(self, process_term_number: int, total_terms: int) -> i depth = int(np.floor(0.25 * smaller_side)) return max(1, depth) + def _down_swing( + self, + psi: np.ndarray, + target: np.ndarray, + subset: List[int], + current_score: float, + depth: int, + squared_y: float, + all_indices: List[int], + all_indices_set: set, + ) -> Tuple[List[int], float, bool, bool]: + """Perform a down swing (remove then add) returning updated state.""" + + if len(subset) < depth: + return subset, current_score, False, True + + working_subset = subset.copy() + to_remove = self._select_least_significant_subset( + psi, target, working_subset, depth, squared_y + ) + + if len(to_remove) != depth: + return subset, current_score, False, True + + working_subset = [t for t in working_subset if t not in to_remove] + available_set = all_indices_set.difference(working_subset) + if len(available_set) < depth: + return subset, current_score, False, True + + available_down = [idx for idx in all_indices if idx in available_set] + ms_terms = self._select_most_significant_subset( + psi, + target, + working_subset, + available_down, + depth, + squared_y, + ) + + if len(ms_terms) != depth: + return subset, current_score, False, True + + working_subset = working_subset + ms_terms + down_score, _ = self._subset_err(psi, target, working_subset, squared_y) + + if down_score > current_score: + return working_subset, down_score, True, False + + return subset, current_score, False, True + + def _up_swing( + self, + psi: np.ndarray, + target: np.ndarray, + subset: List[int], + current_score: float, + depth: int, + squared_y: float, + total_terms: int, + all_indices: List[int], + all_indices_set: set, + ) -> Tuple[List[int], float, bool, bool]: + """Perform an up swing (add then remove) returning updated state.""" + + if len(subset) + depth > total_terms: + return subset, current_score, False, True + + available_set = all_indices_set.difference(subset) + if len(available_set) < depth: + return subset, current_score, False, True + + available_up = [idx for idx in all_indices if idx in available_set] + ms_terms_up = self._select_most_significant_subset( + psi, + target, + subset, + available_up, + depth, + squared_y, + ) + + if len(ms_terms_up) != depth: + return subset, current_score, False, True + + working_subset = subset + ms_terms_up + to_remove_up = self._select_least_significant_subset( + psi, target, working_subset, depth, squared_y + ) + + if len(to_remove_up) != depth: + return subset, current_score, False, True + + working_subset = [t for t in working_subset if t not in to_remove_up] + up_score, _ = self._subset_err(psi, target, working_subset, squared_y) + + if up_score > current_score: + return working_subset, up_score, True, False + + return subset, current_score, False, True + def run_mss_algorithm( self, psi: np.ndarray, y: np.ndarray, process_term_number: int ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Execute the oscillating search with alternating down/up swings.""" target = self._default_estimation_target(y) squared_y = self._compute_squared_y(target) total_terms = psi.shape[1] all_indices = list(range(total_terms)) + all_indices_set = set(all_indices) # Resolve depth once we know xi and n, as suggested by the paper. max_depth = self._resolve_search_depth(process_term_number, total_terms) # Initial model: greedy inclusion of ``process_term_number`` terms. subset: List[int] = [] - available = all_indices.copy() + available_set = all_indices_set.copy() for _ in range(min(process_term_number, total_terms)): - ms_idx, _ = self._best_addition(psi, target, subset, available, squared_y) + available_sorted = [idx for idx in all_indices if idx in available_set] + ms_idx, _ = self._best_addition( + psi, target, subset, available_sorted, squared_y + ) if ms_idx is None: break subset.append(ms_idx) - available.remove(ms_idx) + available_set.discard(ms_idx) current_score, _ = self._subset_err(psi, target, subset, squared_y) - o = 1 - # Flags f1/f2 track consecutive failures of down/up swings as in Alg. 2. - f1 = 0 - f2 = 0 + depth = 1 + failed_down = False + failed_up = False - while o <= max_depth and len(subset) > 0: + while depth <= max_depth and len(subset) > 0: improvement = False - # Down swing: remove exactly o least significant, then add o most significant. - if len(subset) >= o: - down_subset = subset.copy() - to_remove = self._select_least_significant_subset( - psi, target, down_subset, o, squared_y - ) + subset, current_score, down_improved, failed_down = self._down_swing( + psi, + target, + subset, + current_score, + depth, + squared_y, + all_indices, + all_indices_set, + ) + improvement = improvement or down_improved - if len(to_remove) == o: - down_subset = [t for t in down_subset if t not in to_remove] - - available_down = [ - idx for idx in all_indices if idx not in down_subset - ] - if len(available_down) >= o: - ms_terms = self._select_most_significant_subset( - psi, - target, - down_subset, - available_down, - o, - squared_y, - ) - else: - ms_terms = [] - - if len(ms_terms) == o: - down_subset = down_subset + ms_terms - down_score, _ = self._subset_err( - psi, target, down_subset, squared_y - ) - - if down_score > current_score: - subset = down_subset - current_score = down_score - improvement = True - f1 = 0 - else: - f1 = 1 - else: - f1 = 1 - else: - f1 = 1 - else: - f1 = 1 - - # If both down and previous up swings failed, increase depth before the up swing. - if f1 == 1 and f2 == 1: - o += 1 - f1 = 0 - f2 = 0 - if o > max_depth: + if failed_down and failed_up: + depth += 1 + failed_down = False + failed_up = False + if depth > max_depth: break - # Up swing: add o most significant, then remove o least significant. - if len(subset) + o <= total_terms: - up_subset = subset.copy() - available_up = [idx for idx in all_indices if idx not in up_subset] - if len(available_up) >= o: - ms_terms_up = self._select_most_significant_subset( - psi, - target, - up_subset, - available_up, - o, - squared_y, - ) - else: - ms_terms_up = [] - - if len(ms_terms_up) == o: - up_subset = up_subset + ms_terms_up - - to_remove_up = self._select_least_significant_subset( - psi, target, up_subset, o, squared_y - ) - if len(to_remove_up) == o: - up_subset = [t for t in up_subset if t not in to_remove_up] - up_score, _ = self._subset_err( - psi, target, up_subset, squared_y - ) - - if up_score > current_score: - subset = up_subset - current_score = up_score - improvement = True - f2 = 0 - else: - f2 = 1 - else: - f2 = 1 - else: - f2 = 1 - else: - f2 = 1 + subset, current_score, up_improved, failed_up = self._up_swing( + psi, + target, + subset, + current_score, + depth, + squared_y, + total_terms, + all_indices, + all_indices_set, + ) + improvement = improvement or up_improved if improvement: - o = 1 - f1 = 0 - f2 = 0 - else: - if f1 == 1 and f2 == 1: - o += 1 - f1 = 0 - f2 = 0 - else: - # Alternate swings but keep depth. - pass + depth = 1 + failed_down = False + failed_up = False + elif failed_down and failed_up: + depth += 1 + failed_down = False + failed_up = False _, err_vals = self._subset_err(psi, target, subset, squared_y) piv = np.array(subset, dtype=int) diff --git a/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py b/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py index 5358c28c..b60d6327 100644 --- a/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py +++ b/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py @@ -73,6 +73,24 @@ def test_subset_err_empty_and_nonempty(): assert_equal(err_full.tolist(), [1.0, 0.0, 0.0]) +def test_subset_err_zero_pads_when_more_terms_than_samples(): + model = OSF( + n_terms=3, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + ) + psi = np.array([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + target = np.array([[1.0], [0.0]]) + sqy = model._compute_squared_y(target) + score, err = model._subset_err(psi, target, [0, 1, 2], sqy) + assert_equal(err.shape[0], 3) + assert err[2] == 0.0 + assert score == pytest.approx(1.0) + + def test_best_addition_and_removal_ties(): model, psi, target, sqy = _make_base() # tie on addition: target = [1,1,0] @@ -292,6 +310,27 @@ def fake_best_removal(psi_arr, tgt, subset, sqy): model._select_least_significant_subset(psi, target, base_subset, 2, 1.0) +def test_select_least_significant_subset_uses_removed_list(monkeypatch): + model, psi, target, _ = _make_base() + base_subset = [0, 1] + + call_count = {"count": 0} + + def fake_subset_err(psi_arr, tgt, subset, sqy): + call_count["count"] += 1 + if call_count["count"] == 1: + return 0.0, np.array(subset, dtype=float) + return -1.0, np.array(subset, dtype=float) + + monkeypatch.setattr(model, "_subset_err", fake_subset_err) + monkeypatch.setattr( + model, "_best_removal", lambda psi_arr, tgt, subset, sqy: (subset[0], 0.0) + ) + + removed = model._select_least_significant_subset(psi, target, base_subset, 1, 1.0) + assert_equal(removed, [0]) + + def test_osf_run_mss_respects_stored_subset(monkeypatch): model, _, _, _ = _make_base() @@ -572,3 +611,100 @@ def fake_most_significant_terms(psi, target, subset, available, count, sqy): err, piv, psi_sel, _ = model.run_mss_algorithm(psi, y, 1) assert err.size >= 0 assert piv.size >= 0 + + +def test_oos_respects_max_search_depth(monkeypatch): + model = OOS( + n_terms=2, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + max_search_depth=1, + ) + + depth_calls = [] + + def fake_down(*args, **kwargs): + depth_calls.append(args[4]) + return args[2], args[3], False, True + + def fake_up(*args, **kwargs): + depth_calls.append(args[4]) + return args[2], args[3], False, True + + monkeypatch.setattr(model, "_down_swing", fake_down) + monkeypatch.setattr(model, "_up_swing", fake_up) + + psi = np.eye(2) + y = np.ones((3, 1)) + err, piv, _, _ = model.run_mss_algorithm(psi, y, 2) + + assert err.shape[0] == piv.shape[0] + assert depth_calls and max(depth_calls) == 1 + + +def test_down_and_up_swing_keep_score_when_no_improvement(): + model = OOS( + n_terms=2, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + ) + + psi = np.eye(2) + target = np.array([[1.0], [0.0]]) + sqy = model._compute_squared_y(target) + subset = [0, 1] + current_score, _ = model._subset_err(psi, target, subset, sqy) + all_indices = [0, 1] + all_indices_set = set(all_indices) + + updated_subset, updated_score, improved, failed = model._down_swing( + psi, + target, + subset, + current_score, + 1, + sqy, + all_indices, + all_indices_set, + ) + assert updated_subset == subset or updated_score == current_score + assert not improved + assert not failed or updated_score == current_score + + updated_subset, updated_score, improved, failed = model._up_swing( + psi, + target, + subset, + current_score, + 1, + sqy, + len(all_indices), + all_indices, + all_indices_set, + ) + assert updated_subset == subset or updated_score == current_score + assert not improved + assert not failed or updated_score == current_score + + +def test_osf_process_term_number_exceeds_total_terms(): + model = OSF( + n_terms=5, + order_selection=False, + ylag=1, + xlag=1, + basis_function=Polynomial(degree=1), + estimator=LeastSquares(), + ) + psi = np.eye(2) + y = np.ones((3, 1)) + + err, piv, psi_sel, _ = model.run_mss_algorithm(psi, y, 5) + assert piv.shape[0] <= psi.shape[1] + assert err.shape[0] == psi_sel.shape[1] From d52628291359857339e759bdb1b2486b2baf5ec8 Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Mon, 8 Dec 2025 22:37:19 -0300 Subject: [PATCH 08/10] improve docstrings --- .../orthogonal_floating_search.py | 113 +++++++++++------- 1 file changed, 69 insertions(+), 44 deletions(-) diff --git a/sysidentpy/model_structure_selection/orthogonal_floating_search.py b/sysidentpy/model_structure_selection/orthogonal_floating_search.py index 2c726593..04a83bb7 100644 --- a/sysidentpy/model_structure_selection/orthogonal_floating_search.py +++ b/sysidentpy/model_structure_selection/orthogonal_floating_search.py @@ -67,13 +67,7 @@ def _subset_err( subset: List[int], squared_y: float, ) -> Tuple[float, np.ndarray]: - """Compute ERR score for a given subset (Eq. 4–5). - - The ERR of each selected regressor is computed in an orthonormal - basis obtained via QR. The returned score is the sum of ERRs, - matching J(·) in Definition 5. - """ - + """Return ERR score and per-term ERRs for the given subset.""" if not subset: return 0.0, np.array([], dtype=float) @@ -94,7 +88,6 @@ def _subset_err( def _compute_squared_y(self, target: np.ndarray) -> float: """Compute ||y||^2 with numerical floor to avoid division by zero.""" - squared_y = float(np.dot(target.T, target).item()) return squared_y if squared_y > self.eps else float(self.eps) @@ -108,7 +101,6 @@ def _best_addition( squared_y: float, ) -> Tuple[Optional[int], float]: """Pick the most significant term (Definition 1).""" - best_idx: Optional[int] = None best_score = -np.inf for idx in available: @@ -128,7 +120,6 @@ def _best_removal( squared_y: float, ) -> Tuple[int, float]: """Pick the least significant term (Definition 2).""" - best_idx = subset[0] best_score = -np.inf for idx in subset: @@ -148,8 +139,7 @@ def _most_significant_terms( count: int, squared_y: float, ) -> List[int]: - """Exhaustive selection of the most significant ``count``-subset (Definition 3).""" - + """Select the most significant ``count``-subset (Definition 3).""" k = min(count, len(available)) if k <= 0: return [] @@ -176,8 +166,7 @@ def _least_significant_terms( count: int, squared_y: float, ) -> List[int]: - """Exhaustive removal of the least significant ``count``-subset (Definition 4).""" - + """Remove the least significant ``count``-subset (Definition 4).""" k = min(count, len(subset)) if k <= 0: return [] @@ -206,14 +195,11 @@ def _select_most_significant_subset( count: int, squared_y: float, ) -> List[int]: - """Floating forward search (OSF-style) to pick ``count`` terms. + """Floating forward search to pick ``count`` terms (OSF-style). - This mirrors the bottom-up floating strategy but constrains the search - to adding terms on top of a fixed ``base_subset``. Backtracking only - removes terms that were added in this routine, never those in - ``base_subset``. + Constrains additions to build upon ``base_subset`` and backtracks only + terms added in this routine, never those in ``base_subset``. """ - if count <= 0 or not available: return [] @@ -303,11 +289,9 @@ def _select_least_significant_subset( ) -> List[int]: """Sequential backward floating-style removal of ``count`` terms. - Uses repeated evaluation of the removal that maximizes the resulting - criterion. Backtracking avoids undoing the first removal when it is the - most recent change, mirroring the OSF safeguard. + Evaluates removals that maximize the criterion. Backtracking avoids + undoing the first removal when it is the most recent change. """ - if count <= 0 or len(base_subset) == 0: return [] @@ -384,7 +368,6 @@ def _backtrack( last_added: Optional[int], ) -> Tuple[List[int], float]: """Adaptive backward step used by OSF/OIF.""" - flag_first_removal = 1 while len(subset) > 2: ls_idx, ls_score = self._best_removal(psi, target, subset, squared_y) @@ -412,7 +395,6 @@ def _floating_forward_search( swap_callback=None, ) -> List[int]: """Shared floating forward search used by OSF and OIF.""" - total_terms = psi.shape[1] all_indices = list(range(total_terms)) @@ -484,17 +466,31 @@ def _floating_forward_search( class OSF(_OrthogonalFloatingBase): - """Orthogonal Sequential Floating search (paper Section 3.2). + """Orthogonal Sequential Floating search (Section 3.2 of the OFSA paper). - Iteratively adds and conditionally removes regressors based on the ERR - criterion. Preserves API compatibility with other model structure selection - classes; the constructor mirrors ``OFRBase`` arguments. + Iteratively adds regressors using ERR and backtracks to drop weak terms. + Keeps the same constructor surface as other SysIdentPy MSS classes. """ def run_mss_algorithm( self, psi: np.ndarray, y: np.ndarray, process_term_number: int ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: - """Execute the OSF search and return ERR values and selected pivots.""" + """Run OSF and return (err_vals, piv, psi_selected, target). + + Parameters + ---------- + psi : np.ndarray + Candidate regressor matrix with shape (n_samples, n_terms). + y : np.ndarray + Output signal aligned with ``psi``. + process_term_number : int + Maximum number of terms to select. + + Returns + ------- + Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray] + ``(err_vals, piv, psi_selected, target)`` matching the MSS API. + """ target = self._default_estimation_target(y) squared_y = self._compute_squared_y(target) subset = self._floating_forward_search( @@ -508,16 +504,31 @@ def run_mss_algorithm( class OIF(OSF): - """Orthogonal Improved Floating search (paper Section 3.3). + """Orthogonal Improved Floating search (Section 3.3 of the OFSA paper). - Extends ``OSF`` with a swapping step that replaces weak terms with more - significant candidates when it improves the ERR score. + Extends OSF with a swap step that replaces weak terms with better ones + when the ERR score increases. """ def run_mss_algorithm( self, psi: np.ndarray, y: np.ndarray, process_term_number: int ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: - """Execute the OIF search and return ERR values and selected pivots.""" + """Run OIF and return (err_vals, piv, psi_selected, target). + + Parameters + ---------- + psi : np.ndarray + Candidate regressor matrix with shape (n_samples, n_terms). + y : np.ndarray + Output signal aligned with ``psi``. + process_term_number : int + Maximum number of terms to select. + + Returns + ------- + Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray] + ``(err_vals, piv, psi_selected, target)`` matching the MSS API. + """ target = self._default_estimation_target(y) squared_y = self._compute_squared_y(target) subset = self._floating_forward_search( @@ -575,8 +586,8 @@ class OOS(_OrthogonalFloatingBase): """Orthogonal Oscillating Search (paper Section 3.4). This class is named ``OOS`` (Orthogonal Oscillating Search) to avoid - the caret notation ``O^2S`` in code. It corresponds to the same method - described as O²S in the paper. + the caret notation ``O^2S`` in code. It corresponds to the method + described as O2S in the paper. """ def __init__( @@ -621,14 +632,15 @@ def _validate_oos_params(self) -> None: if self.max_search_depth is None: return if not isinstance(self.max_search_depth, int) or self.max_search_depth < 1: - raise ValueError( + msg = ( "max_search_depth must be a positive int or None; " - f"got {self.max_search_depth!r} (type={type(self.max_search_depth).__name__})" + f"got {self.max_search_depth!r} " + f"(type={type(self.max_search_depth).__name__})" ) + raise ValueError(msg) def _resolve_search_depth(self, process_term_number: int, total_terms: int) -> int: """Choose search depth per OFSA guideline (25% of the smaller side).""" - if self.max_search_depth is not None: return self.max_search_depth @@ -650,7 +662,6 @@ def _down_swing( all_indices_set: set, ) -> Tuple[List[int], float, bool, bool]: """Perform a down swing (remove then add) returning updated state.""" - if len(subset) < depth: return subset, current_score, False, True @@ -701,7 +712,6 @@ def _up_swing( all_indices_set: set, ) -> Tuple[List[int], float, bool, bool]: """Perform an up swing (add then remove) returning updated state.""" - if len(subset) + depth > total_terms: return subset, current_score, False, True @@ -741,7 +751,22 @@ def _up_swing( def run_mss_algorithm( self, psi: np.ndarray, y: np.ndarray, process_term_number: int ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: - """Execute the oscillating search with alternating down/up swings.""" + """Run oscillating search and return (err_vals, piv, psi_selected, target). + + Parameters + ---------- + psi : np.ndarray + Candidate regressor matrix with shape (n_samples, n_terms). + y : np.ndarray + Output signal aligned with ``psi``. + process_term_number : int + Maximum number of terms to select. + + Returns + ------- + Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray] + ``(err_vals, piv, psi_selected, target)`` matching the MSS API. + """ target = self._default_estimation_target(y) squared_y = self._compute_squared_y(target) total_terms = psi.shape[1] @@ -823,4 +848,4 @@ def run_mss_algorithm( # Alias matching the notation O²S used in the paper. O2S = OOS -__all__ = ["OSF", "OIF", "OOS", "O2S"] +__all__ = ["O2S", "OIF", "OOS", "OSF"] From d1acbfcca836005cf364cadc46fb760111e61bdd Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Mon, 8 Dec 2025 23:06:25 -0300 Subject: [PATCH 09/10] add tests to cover depth from 1 to 2 on repeated swing failures --- .../tests/test_orthogonal_floating_search.py | 152 ++++++++++++++++++ 1 file changed, 152 insertions(+) diff --git a/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py b/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py index b60d6327..836e61b9 100644 --- a/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py +++ b/sysidentpy/model_structure_selection/tests/test_orthogonal_floating_search.py @@ -613,6 +613,158 @@ def fake_most_significant_terms(psi, target, subset, available, count, sqy): assert piv.size >= 0 +def test_subset_err_handles_zero_columns(): + model = OSF() + psi = np.zeros((0, 1)) + target = np.zeros((0, 1)) + sqy = model._compute_squared_y(target) + + score, err_vals = model._subset_err(psi, target, [0], sqy) + assert score == 0.0 + assert err_vals.size == 0 + + +def test_down_swing_insufficient_most_significant_terms(monkeypatch): + model = OOS() + psi = np.eye(1) + target = np.ones((1, 1)) + sqy = model._compute_squared_y(target) + + monkeypatch.setattr( + model, + "_select_least_significant_subset", + lambda *args, **kwargs: [0], + ) + monkeypatch.setattr( + model, + "_select_most_significant_subset", + lambda *args, **kwargs: [], + ) + + subset, score, improved, failed = model._down_swing( + psi, + target, + [0], + 0.5, + 1, + sqy, + [0], + {0}, + ) + assert subset == [0] + assert score == 0.5 + assert not improved + assert failed + + +def test_up_swing_insufficient_removal(monkeypatch): + model = OOS() + psi = np.eye(2) + target = np.ones((2, 1)) + sqy = model._compute_squared_y(target) + + monkeypatch.setattr( + model, + "_select_most_significant_subset", + lambda *args, **kwargs: [1], + ) + monkeypatch.setattr( + model, + "_select_least_significant_subset", + lambda *args, **kwargs: [], + ) + + subset, score, improved, failed = model._up_swing( + psi, + target, + [0], + 0.5, + 1, + sqy, + 2, + [0, 1], + {0, 1}, + ) + assert subset == [0] + assert score == 0.5 + assert not improved + assert failed + + +def test_oos_run_mss_increments_depth_on_two_failures(monkeypatch): + model = OOS(max_search_depth=2) + psi = np.ones((1, 1)) + y = np.ones((model.max_lag + 1, 1)) + + add_iter = iter([0, None]) + + depth_calls = [] + + def fake_best_addition(*args, **kwargs): + idx = next(add_iter, None) + return (idx, 0.0) if idx is not None else (None, 0.0) + + monkeypatch.setattr(model, "_best_addition", fake_best_addition) + monkeypatch.setattr( + model, + "_down_swing", + lambda *args, **kwargs: ( + depth_calls.append(args[4]) or args[2], + args[3], + False, + True, + ), + ) + monkeypatch.setattr( + model, + "_up_swing", + lambda *args, **kwargs: ( + depth_calls.append(args[4]) or args[2], + args[3], + False, + True, + ), + ) + + err, piv, psi_sel, _ = model.run_mss_algorithm(psi, y, 1) + assert err.size == piv.size == psi_sel.shape[1] + assert depth_calls[:2] == [1, 1] + assert depth_calls[-2:] == [2, 2] + + +def test_down_swing_depth_greater_than_subset(monkeypatch): + model = OOS() + psi = np.eye(1) + target = np.ones((1, 1)) + sqy = model._compute_squared_y(target) + + monkeypatch.setattr( + model, + "_select_least_significant_subset", + lambda *args, **kwargs: [0], + ) + monkeypatch.setattr( + model, + "_select_most_significant_subset", + lambda *args, **kwargs: [], + ) + + subset, score, improved, failed = model._down_swing( + psi, + target, + [0], + 0.5, + 2, + sqy, + [0], + {0}, + ) + assert subset == [0] + assert score == 0.5 + assert not improved + assert failed + + def test_oos_respects_max_search_depth(monkeypatch): model = OOS( n_terms=2, From 72c0a3cc8054dbace20c9b34d7eb753939a55dce Mon Sep 17 00:00:00 2001 From: wilsonrljr Date: Mon, 8 Dec 2025 23:16:52 -0300 Subject: [PATCH 10/10] remove unused imports --- .../model_structure_selection/orthogonal_floating_search.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/sysidentpy/model_structure_selection/orthogonal_floating_search.py b/sysidentpy/model_structure_selection/orthogonal_floating_search.py index 04a83bb7..6210e638 100644 --- a/sysidentpy/model_structure_selection/orthogonal_floating_search.py +++ b/sysidentpy/model_structure_selection/orthogonal_floating_search.py @@ -18,7 +18,7 @@ from ..basis_function import Fourier, Polynomial from ..parameter_estimation.estimators import RecursiveLeastSquares -from .ofr_base import Estimators, OFRBase, _compute_err_slice +from .ofr_base import Estimators, OFRBase class _OrthogonalFloatingBase(OFRBase): @@ -59,7 +59,6 @@ def __init__( apress_lambda=apress_lambda, ) - # --------- low-level ERR utilities --------- def _subset_err( self, psi: np.ndarray, @@ -75,8 +74,6 @@ def _subset_err( if psi_sel.size == 0: return 0.0, np.array([], dtype=float) - # Reduced QR gives orthonormal columns (||w_i||=1), aligning with - # the Gram-Schmidt-based ERR definition without explicit scaling. q, _ = np.linalg.qr(psi_sel, mode="reduced") g = q.T @ target @@ -91,7 +88,6 @@ def _compute_squared_y(self, target: np.ndarray) -> float: squared_y = float(np.dot(target.T, target).item()) return squared_y if squared_y > self.eps else float(self.eps) - # --------- local search building blocks --------- def _best_addition( self, psi: np.ndarray,