poly-basis-ml 0.1.0__tar.gz

poly_basis_ml-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luciano Gerber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

poly_basis_ml-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: poly-basis-ml
+Version: 0.1.0
+Summary: Chebyshev polynomial feature expansion and regression for scikit-learn
+Author-email: Luciano Gerber <L.Gerber@mmu.ac.uk>
+License: MIT
+Project-URL: Homepage, https://github.com/gerberl/poly-basis-ml
+Project-URL: Issues, https://github.com/gerberl/poly-basis-ml/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: scipy>=1.7
+Requires-Dist: scikit-learn>=1.0
+Dynamic: license-file
+
+# poly-basis-ml
+
+Chebyshev polynomial feature expansion and regression for scikit-learn.
+
+[![PyPI version](https://img.shields.io/pypi/v/poly-basis-ml.svg)](https://pypi.org/project/poly-basis-ml/)
+[![Tests](https://github.com/gerberl/poly-basis-ml/actions/workflows/test.yml/badge.svg)](https://github.com/gerberl/poly-basis-ml/actions)
+
+## Installation
+
+```bash
+pip install poly-basis-ml
+```
+
+## Quick start
+
+```python
+from poly_basis_ml import ChebyshevRegressor
+from sklearn.datasets import make_friedman1
+from sklearn.model_selection import train_test_split
+
+X, y = make_friedman1(n_samples=1000, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
+
+model = ChebyshevRegressor(complexity=5, alpha=0.1)
+model.fit(X_train, y_train)
+print(f"R2: {model.score(X_test, y_test):.3f}")
+```
+
+## Key features
+
+- **ChebyshevExpander** --- standalone sklearn transformer for polynomial feature expansion
+- **ChebyshevRegressor** --- convenience estimator wrapping Chebyshev expansion + Ridge
+- **ChebyshevModelTreeRegressor** --- decision tree with Chebyshev polynomial leaf models
+- **Bivariate interactions** --- optional product, contrast, and additive interaction features
+
+## How it works
+
+Features are mapped to [-1, 1] via MinMaxScaler, then expanded into Chebyshev
+polynomial basis functions with proper intercept handling (one T0 term retained,
+redundant constant columns stripped). The resulting design matrix is fitted with
+Ridge regression. For the model tree variant, a decision tree first partitions
+the data into regions, then each leaf fits a separate ChebyshevRegressor for
+smooth local approximation.
+
+## Main classes
+
+### ChebyshevRegressor
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `complexity` | `5` | Chebyshev polynomial degree |
+| `alpha` | `1.0` | Ridge regularisation strength |
+| `clip_input` | `True` | Clip prediction-time inputs to training range |
+| `include_interactions` | `False` | Add bivariate interaction features |
+
+### ChebyshevModelTreeRegressor
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `max_depth` | `3` | Maximum depth of routing tree |
+| `min_samples_leaf` | `200` | Minimum samples per leaf for polynomial fit |
+| `complexity` | `2` | Chebyshev degree for leaf models |
+| `alpha` | `10.0` | Ridge regularisation for leaf models |
+
+## Citation
+
+```bibtex
+@article{gerber2026revisiting,
+  title={Revisiting Chebyshev Polynomial and Anisotropic RBF Models for Tabular Regression},
+  author={Gerber, Luciano and Lloyd, Chris},
+  year={2026}
+}
+```
+
+## Licence
+
+MIT

poly_basis_ml-0.1.0/README.md

@@ -0,0 +1,77 @@
+# poly-basis-ml
+
+Chebyshev polynomial feature expansion and regression for scikit-learn.
+
+[![PyPI version](https://img.shields.io/pypi/v/poly-basis-ml.svg)](https://pypi.org/project/poly-basis-ml/)
+[![Tests](https://github.com/gerberl/poly-basis-ml/actions/workflows/test.yml/badge.svg)](https://github.com/gerberl/poly-basis-ml/actions)
+
+## Installation
+
+```bash
+pip install poly-basis-ml
+```
+
+## Quick start
+
+```python
+from poly_basis_ml import ChebyshevRegressor
+from sklearn.datasets import make_friedman1
+from sklearn.model_selection import train_test_split
+
+X, y = make_friedman1(n_samples=1000, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
+
+model = ChebyshevRegressor(complexity=5, alpha=0.1)
+model.fit(X_train, y_train)
+print(f"R2: {model.score(X_test, y_test):.3f}")
+```
+
+## Key features
+
+- **ChebyshevExpander** --- standalone sklearn transformer for polynomial feature expansion
+- **ChebyshevRegressor** --- convenience estimator wrapping Chebyshev expansion + Ridge
+- **ChebyshevModelTreeRegressor** --- decision tree with Chebyshev polynomial leaf models
+- **Bivariate interactions** --- optional product, contrast, and additive interaction features
+
+## How it works
+
+Features are mapped to [-1, 1] via MinMaxScaler, then expanded into Chebyshev
+polynomial basis functions with proper intercept handling (one T0 term retained,
+redundant constant columns stripped). The resulting design matrix is fitted with
+Ridge regression. For the model tree variant, a decision tree first partitions
+the data into regions, then each leaf fits a separate ChebyshevRegressor for
+smooth local approximation.
+
+## Main classes
+
+### ChebyshevRegressor
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `complexity` | `5` | Chebyshev polynomial degree |
+| `alpha` | `1.0` | Ridge regularisation strength |
+| `clip_input` | `True` | Clip prediction-time inputs to training range |
+| `include_interactions` | `False` | Add bivariate interaction features |
+
+### ChebyshevModelTreeRegressor
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `max_depth` | `3` | Maximum depth of routing tree |
+| `min_samples_leaf` | `200` | Minimum samples per leaf for polynomial fit |
+| `complexity` | `2` | Chebyshev degree for leaf models |
+| `alpha` | `10.0` | Ridge regularisation for leaf models |
+
+## Citation
+
+```bibtex
+@article{gerber2026revisiting,
+  title={Revisiting Chebyshev Polynomial and Anisotropic RBF Models for Tabular Regression},
+  author={Gerber, Luciano and Lloyd, Chris},
+  year={2026}
+}
+```
+
+## Licence
+
+MIT

poly_basis_ml-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "poly-basis-ml"
+version = "0.1.0"
+description = "Chebyshev polynomial feature expansion and regression for scikit-learn"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Luciano Gerber", email = "L.Gerber@mmu.ac.uk"}]
+requires-python = ">=3.9"
+dependencies = [
+    "numpy>=1.21",
+    "scipy>=1.7",
+    "scikit-learn>=1.0",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Intended Audience :: Science/Research",
+]
+
+[project.urls]
+Homepage = "https://github.com/gerberl/poly-basis-ml"
+Issues = "https://github.com/gerberl/poly-basis-ml/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

poly_basis_ml-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

poly_basis_ml-0.1.0/src/poly_basis_ml/__init__.py

@@ -0,0 +1,18 @@
+"""
+poly_basis_ml - Chebyshev polynomial feature expansion and regression.
+"""
+
+from .expanders import ChebyshevExpander
+from .regressor import ChebyshevRegressor
+from .model_tree import ChebyshevModelTreeRegressor
+from .interactions import INTERACTION_FUNCS, RECOMMENDED_INTERACTION_TYPES
+
+__all__ = [
+    'ChebyshevExpander',
+    'ChebyshevRegressor',
+    'ChebyshevModelTreeRegressor',
+    'INTERACTION_FUNCS',
+    'RECOMMENDED_INTERACTION_TYPES',
+]
+
+__version__ = '0.1.0'

poly_basis_ml-0.1.0/src/poly_basis_ml/_vandermonde.py

@@ -0,0 +1,41 @@
+"""
+Low-level Chebyshev Vandermonde matrix generation with intercept handling.
+"""
+
+import numpy as np
+from numpy.polynomial.chebyshev import chebvander
+
+
+def get_vandermonde_matrix(X, complexity):
+    """Generate Chebyshev Vandermonde matrix with intercept handling.
+
+    Keeps T0 from the first feature and strips redundant T0 columns from
+    remaining features to avoid perfect multicollinearity.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples, n_features)
+        Input data, should be scaled to [-1, 1].
+    complexity : int
+        Chebyshev polynomial degree.
+
+    Returns
+    -------
+    vander : ndarray of shape (n_samples, n_terms)
+        Vandermonde matrix with exactly one intercept term.
+    """
+    V_first = chebvander(X[:, 0], complexity)
+    V_rest = [chebvander(X[:, j], complexity)[:, 1:] for j in range(1, X.shape[1])]
+    return np.hstack([V_first] + V_rest)
+
+
+class _VandermondeTransform:
+    """Picklable callable for Vandermonde matrix generation.
+
+    Replaces lambda to enable joblib/pickle serialisation of fitted models.
+    """
+    def __init__(self, complexity):
+        self.complexity = complexity
+
+    def __call__(self, X):
+        return get_vandermonde_matrix(X, self.complexity)

poly_basis_ml-0.1.0/src/poly_basis_ml/expanders.py

@@ -0,0 +1,109 @@
+"""
+ChebyshevExpander: standalone sklearn transformer for Chebyshev polynomial
+feature expansion.
+"""
+
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.utils.validation import check_array, check_is_fitted
+
+from ._vandermonde import get_vandermonde_matrix
+
+
+class ChebyshevExpander(BaseEstimator, TransformerMixin):
+    """Chebyshev polynomial feature expansion.
+
+    Maps features to [-1, 1] via MinMaxScaler, then generates a Chebyshev
+    Vandermonde matrix with proper intercept handling (one T0 term kept,
+    redundant T0 columns stripped).
+
+    Parameters
+    ----------
+    complexity : int, default=5
+        Chebyshev polynomial degree.
+    clip_input : bool, default=True
+        Clip prediction-time inputs to the training range before scaling.
+
+    Attributes
+    ----------
+    scaler_ : MinMaxScaler
+        Fitted scaler mapping features to [-1, 1].
+    n_features_in_ : int
+        Number of input features seen during fit.
+
+    Examples
+    --------
+    >>> from poly_basis_ml import ChebyshevExpander
+    >>> from sklearn.pipeline import Pipeline
+    >>> from sklearn.linear_model import Ridge
+    >>>
+    >>> pipe = Pipeline([('expand', ChebyshevExpander(complexity=5)), ('reg', Ridge())])
+    >>> pipe.fit(X_train, y_train)
+    """
+
+    def __init__(self, complexity=5, clip_input=True):
+        self.complexity = complexity
+        self.clip_input = clip_input
+
+    def fit(self, X, y=None):
+        """Fit the MinMaxScaler to map features to [-1, 1].
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data.
+        y : ignored
+
+        Returns
+        -------
+        self
+        """
+        X = check_array(X)
+        self.n_features_in_ = X.shape[1]
+        self.scaler_ = MinMaxScaler(feature_range=(-1, 1))
+        self.scaler_.fit(X)
+        return self
+
+    def transform(self, X):
+        """Scale to [-1, 1] and generate Chebyshev Vandermonde matrix.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Data to transform.
+
+        Returns
+        -------
+        X_poly : ndarray of shape (n_samples, n_terms)
+            Chebyshev polynomial features.
+        """
+        check_is_fitted(self)
+        X = check_array(X)
+
+        if self.clip_input:
+            X = np.clip(X, self.scaler_.data_min_, self.scaler_.data_max_)
+
+        X_scaled = self.scaler_.transform(X)
+        return get_vandermonde_matrix(X_scaled, self.complexity)
+
+    def get_feature_names_out(self, input_features=None):
+        """Get output feature names.
+
+        Returns
+        -------
+        list of str
+            Names like 'T0_f0', 'T1_f0', ..., 'T1_f1', ...
+        """
+        check_is_fitted(self)
+        d = self.n_features_in_
+        c = self.complexity
+        names = []
+        # First feature keeps T0..Tc
+        for deg in range(c + 1):
+            names.append(f'T{deg}_f0')
+        # Remaining features: T1..Tc (T0 stripped)
+        for j in range(1, d):
+            for deg in range(1, c + 1):
+                names.append(f'T{deg}_f{j}')
+        return names

poly_basis_ml-0.1.0/src/poly_basis_ml/interactions.py

@@ -0,0 +1,200 @@
+"""
+Bivariate interaction functions for feature engineering.
+
+Three families (pick one from each to avoid redundancy):
+- Product family: product, harmonic (multiplicative relationships)
+- Ratio family: contrast, ratio, log_ratio (relative comparisons)
+- Additive family: addition, difference (linear combinations)
+"""
+
+import numpy as np
+from itertools import combinations
+
+from sklearn.base import BaseEstimator
+from sklearn.utils.validation import check_array
+
+from ._vandermonde import get_vandermonde_matrix
+
+
+# --- Interaction functions ---
+
+def _interaction_product(a, b, eps=1e-6):
+    """Product interaction: a * b."""
+    return a * b
+
+def _interaction_harmonic(a, b, eps=1e-6):
+    """Harmonic interaction: 2*a*b / (|a| + |b| + eps)."""
+    return 2 * a * b / (np.abs(a) + np.abs(b) + eps)
+
+def _interaction_contrast(a, b, eps=1e-6):
+    """Contrast interaction: (a - b) / (|a| + |b| + eps)."""
+    return (a - b) / (np.abs(a) + np.abs(b) + eps)
+
+def _interaction_ratio(a, b, eps=1e-6):
+    """Ratio interaction: a / (b + eps). Unbounded."""
+    return a / (b + eps)
+
+def _interaction_log_ratio(a, b, eps=1e-6):
+    """Log-ratio interaction: log(|a| + eps) - log(|b| + eps)."""
+    return np.log(np.abs(a) + eps) - np.log(np.abs(b) + eps)
+
+def _interaction_addition(a, b, eps=1e-6):
+    """Addition interaction: (a + b) / 2."""
+    return (a + b) / 2
+
+def _interaction_difference(a, b, eps=1e-6):
+    """Difference interaction: (a - b) / 2."""
+    return (a - b) / 2
+
+
+INTERACTION_FUNCS = {
+    'product': _interaction_product,
+    'harmonic': _interaction_harmonic,
+    'contrast': _interaction_contrast,
+    'ratio': _interaction_ratio,
+    'log_ratio': _interaction_log_ratio,
+    'addition': _interaction_addition,
+    'difference': _interaction_difference,
+}
+
+RECOMMENDED_INTERACTION_TYPES = ['product', 'contrast', 'addition']
+
+
+class _PolyInteractionTransform(BaseEstimator):
+    """Sklearn transformer for combined Chebyshev polynomial + interaction features.
+
+    Generates Chebyshev Vandermonde matrix and optionally adds interaction features.
+    Supports variance-based and MI-based feature ranking for pair selection.
+    """
+
+    def __init__(self, complexity,
+                 include_interactions=False, interaction_types=None,
+                 interaction_pairs='auto', interaction_d_threshold=30,
+                 interaction_top_frac=0.5, interaction_top_n=None,
+                 max_interactions=100,
+                 expand_interactions=False, max_interaction_complexity=5,
+                 interaction_ranking='variance', mi_spearman_threshold=0.1):
+        self.complexity = complexity
+        self.include_interactions = include_interactions
+        self.interaction_types = interaction_types or ['product']
+        self.interaction_pairs = interaction_pairs
+        self.interaction_d_threshold = interaction_d_threshold
+        self.interaction_top_frac = interaction_top_frac
+        self.interaction_top_n = interaction_top_n
+        self.max_interactions = max_interactions
+        self.expand_interactions = expand_interactions
+        self.max_interaction_complexity = max_interaction_complexity
+        self.interaction_ranking = interaction_ranking
+        self.mi_spearman_threshold = mi_spearman_threshold
+        self._interaction_pairs_cache = None
+        self._feature_ranking = None
+
+    def _rank_features_variance(self, X):
+        variances = np.var(X, axis=0)
+        return np.argsort(variances)[::-1]
+
+    def _rank_features_mi_rescue(self, X, y):
+        from scipy.stats import spearmanr
+        from sklearn.feature_selection import mutual_info_regression
+
+        n_features = X.shape[1]
+        spearman_scores = np.array([
+            abs(spearmanr(X[:, i], y, nan_policy='omit')[0])
+            for i in range(n_features)
+        ])
+        spearman_scores = np.nan_to_num(spearman_scores, nan=0.0)
+
+        low_spearman_mask = spearman_scores < self.mi_spearman_threshold
+        mi_scores = np.zeros(n_features)
+        if low_spearman_mask.any():
+            rescue_indices = np.where(low_spearman_mask)[0]
+            mi_rescue = mutual_info_regression(
+                X[:, rescue_indices], y, random_state=42
+            )
+            mi_scores[rescue_indices] = mi_rescue
+
+        spearman_max = spearman_scores.max()
+        spearman_norm = spearman_scores / (spearman_max + 1e-10) if spearman_max > 0 else spearman_scores
+        mi_max = mi_scores.max()
+        mi_norm = mi_scores / (mi_max + 1e-10) if mi_max > 0 else mi_scores
+
+        combined_scores = np.where(
+            low_spearman_mask & (mi_norm > spearman_norm),
+            mi_norm, spearman_norm
+        )
+        return np.argsort(combined_scores)[::-1]
+
+    def _compute_feature_ranking(self, X, y=None):
+        if self.interaction_ranking == 'mi_rescue' and y is not None:
+            return self._rank_features_mi_rescue(X, y)
+        return self._rank_features_variance(X)
+
+    def _get_pairs_from_ranking(self, X, ranking):
+        n_features = X.shape[1]
+
+        if not self.include_interactions or self.interaction_pairs == 'none':
+            return []
+
+        if self.interaction_pairs == 'auto':
+            if n_features <= self.interaction_d_threshold:
+                pairs = list(combinations(range(n_features), 2))
+            else:
+                n_top = max(2, int(n_features * self.interaction_top_frac))
+                top_indices = ranking[:n_top]
+                pairs = list(combinations(sorted(top_indices), 2))
+        elif self.interaction_pairs == 'all':
+            pairs = list(combinations(range(n_features), 2))
+        elif self.interaction_pairs == 'top_n':
+            n = self.interaction_top_n or min(n_features, 10)
+            top_indices = ranking[:n]
+            pairs = list(combinations(sorted(top_indices), 2))
+        else:
+            pairs = list(combinations(range(n_features), 2))
+
+        if self.max_interactions is not None:
+            n_types = len(self.interaction_types)
+            max_pairs = self.max_interactions // max(1, n_types)
+            if len(pairs) > max_pairs:
+                rank_lookup = {idx: rank for rank, idx in enumerate(ranking)}
+                pair_scores = [
+                    (i, j, rank_lookup.get(i, n_features) + rank_lookup.get(j, n_features))
+                    for i, j in pairs
+                ]
+                pair_scores.sort(key=lambda x: x[2])
+                pairs = [(p[0], p[1]) for p in pair_scores[:max_pairs]]
+
+        return pairs
+
+    def fit(self, X, y=None):
+        X = check_array(X)
+        self._feature_ranking = self._compute_feature_ranking(X, y)
+        self._interaction_pairs_cache = self._get_pairs_from_ranking(X, self._feature_ranking)
+        return self
+
+    def transform(self, X):
+        X = check_array(X)
+        X_poly = get_vandermonde_matrix(X, self.complexity)
+
+        if self.include_interactions and self._interaction_pairs_cache:
+            interaction_blocks = []
+            for i, j in self._interaction_pairs_cache:
+                for itype in self.interaction_types:
+                    func = INTERACTION_FUNCS[itype]
+                    z = func(X[:, i], X[:, j])
+
+                    if self.expand_interactions:
+                        z_clipped = np.clip(z, -1, 1).reshape(-1, 1)
+                        inter_complexity = min(self.complexity, self.max_interaction_complexity)
+                        z_poly = get_vandermonde_matrix(z_clipped, inter_complexity)
+                        interaction_blocks.append(z_poly[:, 1:])
+                    else:
+                        interaction_blocks.append(z.reshape(-1, 1))
+
+            if interaction_blocks:
+                X_inter = np.hstack(interaction_blocks)
+                return np.hstack([X_poly, X_inter])
+
+        return X_poly
+
+    def fit_transform(self, X, y=None):
+        return self.fit(X, y).transform(X)

poly_basis_ml-0.1.0/src/poly_basis_ml/model_tree.py

@@ -0,0 +1,135 @@
+"""
+ChebyshevModelTreeRegressor: decision tree with Chebyshev polynomial leaf models.
+"""
+
+import numpy as np
+from sklearn.base import BaseEstimator, RegressorMixin
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
+from sklearn.metrics import r2_score
+
+from .regressor import ChebyshevRegressor
+
+
+class ChebyshevModelTreeRegressor(BaseEstimator, RegressorMixin):
+    """Decision tree with Chebyshev polynomial leaf models.
+
+    The routing tree partitions the feature space into regions, then each
+    leaf fits a ChebyshevRegressor for local approximation.
+
+    Parameters
+    ----------
+    max_depth : int, default=3
+        Maximum depth of the routing tree.
+    min_samples_leaf : int or float, default=200
+        Minimum samples per leaf for fitting a polynomial model.
+        Leaves with fewer samples fall back to tree prediction.
+        If int, the absolute minimum number of samples.
+        If float, a fraction of n_samples (consistent with sklearn).
+    complexity : int, default=2
+        Chebyshev polynomial degree for leaf models.
+    alpha : float, default=10.0
+        Ridge regularisation strength for leaf models.
+    routing_features : list of int or None, default=None
+        Column indices for tree routing. If None, uses all.
+    leaf_features : list of int or None, default=None
+        Column indices for leaf models. If None, uses all.
+    random_state : int, default=42
+        Random state for reproducibility.
+
+    Examples
+    --------
+    >>> from poly_basis_ml import ChebyshevModelTreeRegressor
+    >>> model = ChebyshevModelTreeRegressor(max_depth=3, complexity=2)
+    >>> model.fit(X_train, y_train)
+    >>> print(f"R2: {model.score(X_test, y_test):.3f}")
+    """
+
+    def __init__(self, max_depth=3, min_samples_leaf=200,
+                 complexity=2, alpha=10.0,
+                 routing_features=None, leaf_features=None,
+                 random_state=42):
+        self.max_depth = max_depth
+        self.min_samples_leaf = min_samples_leaf
+        self.complexity = complexity
+        self.alpha = alpha
+        self.routing_features = routing_features
+        self.leaf_features = leaf_features
+        self.random_state = random_state
+
+    def fit(self, X, y):
+        """Fit model tree with Chebyshev leaf models.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+        y : array-like of shape (n_samples,)
+
+        Returns
+        -------
+        self
+        """
+        X, y = check_X_y(X, y)
+        self.n_features_in_ = X.shape[1]
+        n_samples = X.shape[0]
+
+        # Resolve min_samples_leaf: float means fraction of n_samples
+        if isinstance(self.min_samples_leaf, float):
+            min_leaf_abs = max(1, int(np.ceil(self.min_samples_leaf * n_samples)))
+        else:
+            min_leaf_abs = self.min_samples_leaf
+
+        X_route = X[:, self.routing_features] if self.routing_features is not None else X
+        X_leaf = X[:, self.leaf_features] if self.leaf_features is not None else X
+
+        # Fit routing tree (sklearn handles int/float min_samples_leaf natively)
+        self.tree_ = DecisionTreeRegressor(
+            max_depth=self.max_depth,
+            min_samples_leaf=self.min_samples_leaf,
+            random_state=self.random_state,
+        )
+        self.tree_.fit(X_route, y)
+
+        # Fit leaf models
+        leaf_ids = self.tree_.apply(X_route)
+        self.leaf_models_ = {}
+        for leaf_id in np.unique(leaf_ids):
+            mask = leaf_ids == leaf_id
+            if mask.sum() >= min_leaf_abs:
+                self.leaf_models_[leaf_id] = ChebyshevRegressor(
+                    complexity=self.complexity, alpha=self.alpha,
+                ).fit(X_leaf[mask], y[mask])
+
+        return self
+
+    def predict(self, X):
+        """Predict using fitted model tree.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+
+        Returns
+        -------
+        y_pred : ndarray of shape (n_samples,)
+        """
+        check_is_fitted(self, ['tree_', 'leaf_models_'])
+        X = check_array(X)
+
+        X_route = X[:, self.routing_features] if self.routing_features is not None else X
+        X_leaf = X[:, self.leaf_features] if self.leaf_features is not None else X
+
+        leaf_ids = self.tree_.apply(X_route)
+        y_pred = np.full(len(X), np.nan)
+
+        for leaf_id, model in self.leaf_models_.items():
+            mask = leaf_ids == leaf_id
+            if mask.any():
+                y_pred[mask] = model.predict(X_leaf[mask])
+
+        # Fallback for leaves without polynomial model
+        nan_mask = np.isnan(y_pred)
+        if nan_mask.any():
+            y_pred[nan_mask] = self.tree_.predict(X_route[nan_mask])
+
+        return y_pred

poly_basis_ml-0.1.0/src/poly_basis_ml/regressor.py

@@ -0,0 +1,138 @@
+"""
+ChebyshevRegressor: convenience estimator wrapping ChebyshevExpander + Ridge.
+"""
+
+import numpy as np
+from sklearn.base import BaseEstimator, RegressorMixin
+from sklearn.linear_model import Ridge
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import MinMaxScaler, FunctionTransformer
+from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
+from sklearn.metrics import r2_score
+
+from ._vandermonde import _VandermondeTransform
+from .interactions import _PolyInteractionTransform
+
+
+class ChebyshevRegressor(BaseEstimator, RegressorMixin):
+    """Chebyshev polynomial regression with Ridge regularisation.
+
+    Internally builds Pipeline(MinMaxScaler, ChebyshevVandermonde, Ridge).
+    Optionally adds bivariate interaction features.
+
+    Parameters
+    ----------
+    complexity : int, default=5
+        Chebyshev polynomial degree.
+    alpha : float, default=1.0
+        Ridge regularisation strength.
+    clip_input : bool, default=True
+        Clip prediction-time inputs to training range.
+    include_interactions : bool, default=False
+        Whether to generate interaction features.
+    interaction_types : list of str or None
+        Types of interactions (default: ['product']).
+    interaction_pairs : str, default='auto'
+        Which pairs: 'auto', 'all', 'top_n', 'none'.
+    max_interactions : int, default=100
+        Hard limit on interaction pairs.
+    expand_interactions : bool, default=False
+        Apply Chebyshev expansion to interactions.
+    max_interaction_complexity : int, default=5
+        Max degree for interaction expansion.
+    interaction_ranking : str, default='variance'
+        Feature ranking: 'variance' or 'mi_rescue'.
+
+    Examples
+    --------
+    >>> from poly_basis_ml import ChebyshevRegressor
+    >>> model = ChebyshevRegressor(complexity=8, alpha=0.1)
+    >>> model.fit(X_train, y_train)
+    >>> print(f"R2: {model.score(X_test, y_test):.3f}")
+    """
+
+    def __init__(self, complexity=5, alpha=1.0, clip_input=True,
+                 include_interactions=False, interaction_types=None,
+                 interaction_pairs='auto', max_interactions=100,
+                 expand_interactions=False, max_interaction_complexity=5,
+                 interaction_ranking='variance'):
+        self.complexity = complexity
+        self.alpha = alpha
+        self.clip_input = clip_input
+        self.include_interactions = include_interactions
+        self.interaction_types = interaction_types
+        self.interaction_pairs = interaction_pairs
+        self.max_interactions = max_interactions
+        self.expand_interactions = expand_interactions
+        self.max_interaction_complexity = max_interaction_complexity
+        self.interaction_ranking = interaction_ranking
+
+    def fit(self, X, y):
+        """Fit the Chebyshev regression model.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+        y : array-like of shape (n_samples,)
+
+        Returns
+        -------
+        self
+        """
+        X, y = check_X_y(X, y)
+        self.n_features_in_ = X.shape[1]
+
+        if self.include_interactions:
+            transform = _PolyInteractionTransform(
+                complexity=self.complexity,
+                include_interactions=True,
+                interaction_types=self.interaction_types or ['product'],
+                interaction_pairs=self.interaction_pairs,
+                max_interactions=self.max_interactions,
+                expand_interactions=self.expand_interactions,
+                max_interaction_complexity=self.max_interaction_complexity,
+                interaction_ranking=self.interaction_ranking,
+            )
+            self.pipe_ = Pipeline([
+                ('scl', MinMaxScaler(feature_range=(-1, 1))),
+                ('vdr', transform),
+                ('reg', Ridge(alpha=self.alpha, fit_intercept=False)),
+            ])
+        else:
+            transform = _VandermondeTransform(self.complexity)
+            self.pipe_ = Pipeline([
+                ('scl', MinMaxScaler(feature_range=(-1, 1))),
+                ('vdr', FunctionTransformer(transform)),
+                ('reg', Ridge(alpha=self.alpha, fit_intercept=False)),
+            ])
+
+        self.pipe_.fit(X, y)
+        return self
+
+    def predict(self, X):
+        """Predict target values.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+
+        Returns
+        -------
+        y_pred : ndarray of shape (n_samples,)
+        """
+        check_is_fitted(self, 'pipe_')
+        X = check_array(X)
+        if self.clip_input:
+            scaler = self.pipe_['scl']
+            X = np.clip(X, scaler.data_min_, scaler.data_max_)
+        return self.pipe_.predict(X)
+
+    @property
+    def coef_(self):
+        check_is_fitted(self, 'pipe_')
+        return self.pipe_['reg'].coef_
+
+    @property
+    def intercept_(self):
+        check_is_fitted(self, 'pipe_')
+        return self.pipe_['reg'].intercept_

poly_basis_ml-0.1.0/src/poly_basis_ml.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: poly-basis-ml
+Version: 0.1.0
+Summary: Chebyshev polynomial feature expansion and regression for scikit-learn
+Author-email: Luciano Gerber <L.Gerber@mmu.ac.uk>
+License: MIT
+Project-URL: Homepage, https://github.com/gerberl/poly-basis-ml
+Project-URL: Issues, https://github.com/gerberl/poly-basis-ml/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: scipy>=1.7
+Requires-Dist: scikit-learn>=1.0
+Dynamic: license-file
+
+# poly-basis-ml
+
+Chebyshev polynomial feature expansion and regression for scikit-learn.
+
+[![PyPI version](https://img.shields.io/pypi/v/poly-basis-ml.svg)](https://pypi.org/project/poly-basis-ml/)
+[![Tests](https://github.com/gerberl/poly-basis-ml/actions/workflows/test.yml/badge.svg)](https://github.com/gerberl/poly-basis-ml/actions)
+
+## Installation
+
+```bash
+pip install poly-basis-ml
+```
+
+## Quick start
+
+```python
+from poly_basis_ml import ChebyshevRegressor
+from sklearn.datasets import make_friedman1
+from sklearn.model_selection import train_test_split
+
+X, y = make_friedman1(n_samples=1000, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
+
+model = ChebyshevRegressor(complexity=5, alpha=0.1)
+model.fit(X_train, y_train)
+print(f"R2: {model.score(X_test, y_test):.3f}")
+```
+
+## Key features
+
+- **ChebyshevExpander** --- standalone sklearn transformer for polynomial feature expansion
+- **ChebyshevRegressor** --- convenience estimator wrapping Chebyshev expansion + Ridge
+- **ChebyshevModelTreeRegressor** --- decision tree with Chebyshev polynomial leaf models
+- **Bivariate interactions** --- optional product, contrast, and additive interaction features
+
+## How it works
+
+Features are mapped to [-1, 1] via MinMaxScaler, then expanded into Chebyshev
+polynomial basis functions with proper intercept handling (one T0 term retained,
+redundant constant columns stripped). The resulting design matrix is fitted with
+Ridge regression. For the model tree variant, a decision tree first partitions
+the data into regions, then each leaf fits a separate ChebyshevRegressor for
+smooth local approximation.
+
+## Main classes
+
+### ChebyshevRegressor
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `complexity` | `5` | Chebyshev polynomial degree |
+| `alpha` | `1.0` | Ridge regularisation strength |
+| `clip_input` | `True` | Clip prediction-time inputs to training range |
+| `include_interactions` | `False` | Add bivariate interaction features |
+
+### ChebyshevModelTreeRegressor
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `max_depth` | `3` | Maximum depth of routing tree |
+| `min_samples_leaf` | `200` | Minimum samples per leaf for polynomial fit |
+| `complexity` | `2` | Chebyshev degree for leaf models |
+| `alpha` | `10.0` | Ridge regularisation for leaf models |
+
+## Citation
+
+```bibtex
+@article{gerber2026revisiting,
+  title={Revisiting Chebyshev Polynomial and Anisotropic RBF Models for Tabular Regression},
+  author={Gerber, Luciano and Lloyd, Chris},
+  year={2026}
+}
+```
+
+## Licence
+
+MIT

poly_basis_ml-0.1.0/src/poly_basis_ml.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/poly_basis_ml/__init__.py
+src/poly_basis_ml/_vandermonde.py
+src/poly_basis_ml/expanders.py
+src/poly_basis_ml/interactions.py
+src/poly_basis_ml/model_tree.py
+src/poly_basis_ml/regressor.py
+src/poly_basis_ml.egg-info/PKG-INFO
+src/poly_basis_ml.egg-info/SOURCES.txt
+src/poly_basis_ml.egg-info/dependency_links.txt
+src/poly_basis_ml.egg-info/requires.txt
+src/poly_basis_ml.egg-info/top_level.txt
+tests/test_expander.py
+tests/test_model_tree.py
+tests/test_regressor.py

poly_basis_ml-0.1.0/src/poly_basis_ml.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

poly_basis_ml-0.1.0/src/poly_basis_ml.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.21
+scipy>=1.7
+scikit-learn>=1.0

poly_basis_ml-0.1.0/src/poly_basis_ml.egg-info/top_level.txt

@@ -0,0 +1 @@
+poly_basis_ml

poly_basis_ml-0.1.0/tests/test_expander.py

@@ -0,0 +1,61 @@
+"""Tests for ChebyshevExpander."""
+
+import numpy as np
+import pytest
+from sklearn.base import clone
+from sklearn.pipeline import Pipeline
+from sklearn.linear_model import Ridge
+
+from poly_basis_ml import ChebyshevExpander
+
+
+def test_fit_transform_shape():
+    """Output shape (n, d*complexity + 1)."""
+    rng = np.random.RandomState(0)
+    X = rng.randn(100, 3)
+    exp = ChebyshevExpander(complexity=4)
+    X_out = exp.fit_transform(X)
+    # First feature: 5 cols (T0..T4), others: 4 cols each (T1..T4)
+    expected_cols = 5 + 2 * 4
+    assert X_out.shape == (100, expected_cols)
+
+
+def test_transform_clipping():
+    """Out-of-range inputs handled via clipping."""
+    rng = np.random.RandomState(0)
+    X_train = rng.randn(100, 2)
+    exp = ChebyshevExpander(complexity=3)
+    exp.fit(X_train)
+    # Test with out-of-range values
+    X_test = X_train * 5
+    X_out = exp.transform(X_test)
+    assert not np.any(np.isnan(X_out))
+
+
+def test_feature_names_out():
+    """Returns T0_f0, T1_f0, ..."""
+    rng = np.random.RandomState(0)
+    X = rng.randn(50, 2)
+    exp = ChebyshevExpander(complexity=3)
+    exp.fit(X)
+    names = exp.get_feature_names_out()
+    assert names[0] == 'T0_f0'
+    assert names[1] == 'T1_f0'
+    assert 'T1_f1' in names
+
+
+def test_sklearn_clone():
+    exp = ChebyshevExpander(complexity=7)
+    cloned = clone(exp)
+    assert cloned.complexity == 7
+
+
+def test_pipeline_integration():
+    """Pipeline([ChebyshevExpander(), Ridge()]).fit works."""
+    rng = np.random.RandomState(42)
+    X = rng.randn(200, 3)
+    y = X[:, 0] ** 2 + rng.normal(0, 0.1, 200)
+    pipe = Pipeline([('expand', ChebyshevExpander(complexity=4)), ('reg', Ridge())])
+    pipe.fit(X, y)
+    r2 = pipe.score(X, y)
+    assert r2 > 0.5

poly_basis_ml-0.1.0/tests/test_model_tree.py

@@ -0,0 +1,37 @@
+"""Tests for ChebyshevModelTreeRegressor."""
+
+import numpy as np
+from poly_basis_ml import ChebyshevModelTreeRegressor
+
+
+def test_fit_predict_basic():
+    """Synthetic data, R2 > 0."""
+    rng = np.random.RandomState(42)
+    X = rng.randn(500, 3)
+    y = np.where(X[:, 0] > 0, X[:, 1] ** 2, -X[:, 1]) + rng.normal(0, 0.1, 500)
+    model = ChebyshevModelTreeRegressor(max_depth=2, min_samples_leaf=50, complexity=2)
+    model.fit(X, y)
+    r2 = model.score(X, y)
+    assert r2 > 0, f"R2={r2:.3f}"
+
+
+def test_min_samples_leaf_fallback():
+    """Tiny leaf falls back to tree prediction."""
+    rng = np.random.RandomState(42)
+    X = rng.randn(100, 2)
+    y = X[:, 0] + rng.normal(0, 0.1, 100)
+    # Very high min_samples_leaf so most leaves fall back
+    model = ChebyshevModelTreeRegressor(max_depth=5, min_samples_leaf=80)
+    model.fit(X, y)
+    pred = model.predict(X)
+    assert pred.shape == (100,)
+    assert not np.any(np.isnan(pred))
+
+
+def test_get_set_params():
+    model = ChebyshevModelTreeRegressor(max_depth=4, complexity=3)
+    params = model.get_params()
+    assert params['max_depth'] == 4
+    assert params['complexity'] == 3
+    model.set_params(max_depth=2)
+    assert model.max_depth == 2

poly_basis_ml-0.1.0/tests/test_regressor.py

@@ -0,0 +1,45 @@
+"""Tests for ChebyshevRegressor."""
+
+import numpy as np
+from poly_basis_ml import ChebyshevRegressor
+
+
+def test_fit_predict_1d_sin():
+    """sin(x), R2 > 0.95 with complexity=8."""
+    rng = np.random.RandomState(42)
+    X = rng.uniform(-3, 3, (300, 1))
+    y = np.sin(X[:, 0]) + rng.normal(0, 0.05, 300)
+    model = ChebyshevRegressor(complexity=8, alpha=0.01)
+    model.fit(X, y)
+    r2 = model.score(X, y)
+    assert r2 > 0.95, f"R2={r2:.3f}"
+
+
+def test_fit_predict_nd_friedman1():
+    """friedman1, R2 > 0.5."""
+    from sklearn.datasets import make_friedman1
+    X, y = make_friedman1(n_samples=500, n_features=5, random_state=42)
+    model = ChebyshevRegressor(complexity=3, alpha=1.0)
+    model.fit(X, y)
+    r2 = model.score(X, y)
+    assert r2 > 0.5, f"R2={r2:.3f}"
+
+
+def test_with_interactions():
+    """include_interactions=True runs without error."""
+    rng = np.random.RandomState(42)
+    X = rng.randn(200, 4)
+    y = X[:, 0] * X[:, 1] + rng.normal(0, 0.1, 200)
+    model = ChebyshevRegressor(complexity=3, include_interactions=True)
+    model.fit(X, y)
+    pred = model.predict(X)
+    assert pred.shape == (200,)
+
+
+def test_get_set_params():
+    model = ChebyshevRegressor(complexity=5, alpha=0.5)
+    params = model.get_params()
+    assert params['complexity'] == 5
+    assert params['alpha'] == 0.5
+    model.set_params(complexity=3)
+    assert model.complexity == 3