robustkit 0.0.1__tar.gz

robustkit-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mikael Lundqvist
+
+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.

robustkit-0.0.1/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: robustkit
+Version: 0.0.1
+Summary: Practical tools for robust analysis of a single continuous relationship: trend fitting, stability checks, influence diagnostics, and bootstrap uncertainty.
+Author: Mikael Lundqvist
+License: MIT License
+        
+        Copyright (c) 2026 Mikael Lundqvist
+        
+        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.
+        
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: statsmodels>=0.14
+Requires-Dist: scipy>=1.10
+Requires-Dist: matplotlib>=3.7
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# robustkit
+
+> ⚠️ **Under active development.** This is an early placeholder release
+> to claim the package name on PyPI. The API is incomplete and may
+> change without notice. Not yet recommended for production use.
+
+Practical tools for robust analysis of a single continuous relationship:
+y as a function of one continuous x.
+
+The guiding idea: **a conclusion that survives multiple fitting methods
+is more trustworthy than one that only holds under a single model.**
+`robustkit` makes it easy to compare Huber, Tukey biweight, and OLS
+fits side by side, identify and quantify the influence of individual
+observations, and get honest, bias-corrected uncertainty estimates.
+
+## Status
+
+`robustkit.core` (trend fitting, stability, diagnostics, uncertainty,
+consistency checks), `robustkit.segmentation` (hierarchical grouping,
+per-segment analysis), and `robustkit.information` (mutual-information
+feature ranking) are stable and tested. A more advanced
+information-theoretic pairing layer (conditional MI for a second
+variable, synergy/redundancy scoring) is planned but not yet included.
+
+## Installation
+
+```bash
+git clone https://github.com/<your-username>/robustkit.git
+cd robustkit
+pip install -e ".[dev]"
+```
+
+## Quickstart
+
+```python
+import numpy as np
+from robustkit import (
+    fit_huber_trend, fit_tukey_trend, predict_trend,
+    model_stability_pct, cooks_diagnostic, cook_impact,
+    bootstrap_band, bca_bootstrap_ci,
+)
+
+# x: a single continuous predictor, y: a single continuous outcome
+x = np.random.default_rng(0).uniform(20, 60, 200)
+y = 1000 + 50 * x - 0.4 * x**2 + np.random.default_rng(1).normal(0, 500, 200)
+
+fit = fit_huber_trend(x, y, degree=2)
+y_pred = predict_trend(fit, x_new=[30, 40, 50])
+
+stability = model_stability_pct(x, y)
+print("Median % spread between Huber/Tukey/OLS:", stability["median_pct_diff"])
+
+diag = cooks_diagnostic(x, y)
+impact = cook_impact(x, y, diag["flagged_indices"])
+print("Median % change in curve if flagged points removed:", impact["median_pct_change"])
+
+band = bootstrap_band(x, y)
+ci = bca_bootstrap_ci(x, y, statistic_fn=lambda x_, y_: np.median(y_))
+```
+
+See `examples/quickstart_tutorial.py` for a complete, runnable walkthrough.
+
+## Segmentation
+
+Run any `robustkit.core` analysis independently across subgroups of a
+larger dataset, with automatic fallback to coarser groupings when a
+finer one is too small to analyze reliably:
+
+```python
+from robustkit import hierarchical_segment, apply_by_segment, model_stability_pct
+
+hierarchy = [["department", "level", "status"], ["level", "status"], ["status"]]
+segmented = hierarchical_segment(df, hierarchy, min_size=20)
+
+report = apply_by_segment(
+    segmented, segment_col="segment_id", x_col="age", y_col="value",
+    analysis_fn=model_stability_pct,
+)
+```
+
+`apply_by_segment` works with any function shaped like
+`analysis_fn(x, y, **kwargs) -> dict` -- built-in ones
+(`model_stability_pct`, `cook_impact`, `bca_bootstrap_ci`, ...) or your
+own. Only scalar values in the returned dict end up in the report
+table; segments below `min_points` are skipped rather than causing an
+error.
+
+## Feature ranking (information)
+
+Rank features by mutual information with a target, normalized by each
+feature's own entropy, and classify them into four quadrants:
+
+```python
+from robustkit import rank_features, quadrant_report, plot_feature_space
+
+ranking = rank_features(df, target="value")
+report = quadrant_report(df, target="value")   # adds a `quadrant` column
+plot_feature_space(df, target="value")          # same quadrants, visualized
+```
+
+`quadrant_report` and `plot_feature_space` always agree on quadrant
+assignment -- both route through the same thresholding logic.
+
+**Caveat:** default thresholds are the *median* mutual information /
+efficiency across the ranked features. With only a handful of
+features, this can put a genuinely weak feature in the same "high"
+half as a strong one, since roughly half of any list sits above its
+own median regardless of how large the actual gap is. Median
+thresholding becomes meaningful with a reasonably large feature set;
+for a handful of candidates, read the raw `mutual_information` /
+`information_efficiency` values directly rather than relying on the
+quadrant label alone.
+
+See `examples/information_tutorial.py` for a complete walkthrough.
+
+## Design principles
+
+- **One continuous x, one continuous y** at the core. This keeps every
+  function's output visually and numerically interpretable (a curve
+  you can plot, a band you can read).
+- **Diagnosis and action are separate steps.** `cooks_diagnostic`
+  flags candidates; `cook_impact` tells you whether removing them
+  actually changes anything.
+- **OLS is a reference point, not the enemy.** Comparing robust fits
+  against OLS is how you know whether robustness mattered at all.
+
+## License
+
+MIT -- see [LICENSE](LICENSE).

robustkit-0.0.1/README.md

@@ -0,0 +1,129 @@
+# robustkit
+
+> ⚠️ **Under active development.** This is an early placeholder release
+> to claim the package name on PyPI. The API is incomplete and may
+> change without notice. Not yet recommended for production use.
+
+Practical tools for robust analysis of a single continuous relationship:
+y as a function of one continuous x.
+
+The guiding idea: **a conclusion that survives multiple fitting methods
+is more trustworthy than one that only holds under a single model.**
+`robustkit` makes it easy to compare Huber, Tukey biweight, and OLS
+fits side by side, identify and quantify the influence of individual
+observations, and get honest, bias-corrected uncertainty estimates.
+
+## Status
+
+`robustkit.core` (trend fitting, stability, diagnostics, uncertainty,
+consistency checks), `robustkit.segmentation` (hierarchical grouping,
+per-segment analysis), and `robustkit.information` (mutual-information
+feature ranking) are stable and tested. A more advanced
+information-theoretic pairing layer (conditional MI for a second
+variable, synergy/redundancy scoring) is planned but not yet included.
+
+## Installation
+
+```bash
+git clone https://github.com/<your-username>/robustkit.git
+cd robustkit
+pip install -e ".[dev]"
+```
+
+## Quickstart
+
+```python
+import numpy as np
+from robustkit import (
+    fit_huber_trend, fit_tukey_trend, predict_trend,
+    model_stability_pct, cooks_diagnostic, cook_impact,
+    bootstrap_band, bca_bootstrap_ci,
+)
+
+# x: a single continuous predictor, y: a single continuous outcome
+x = np.random.default_rng(0).uniform(20, 60, 200)
+y = 1000 + 50 * x - 0.4 * x**2 + np.random.default_rng(1).normal(0, 500, 200)
+
+fit = fit_huber_trend(x, y, degree=2)
+y_pred = predict_trend(fit, x_new=[30, 40, 50])
+
+stability = model_stability_pct(x, y)
+print("Median % spread between Huber/Tukey/OLS:", stability["median_pct_diff"])
+
+diag = cooks_diagnostic(x, y)
+impact = cook_impact(x, y, diag["flagged_indices"])
+print("Median % change in curve if flagged points removed:", impact["median_pct_change"])
+
+band = bootstrap_band(x, y)
+ci = bca_bootstrap_ci(x, y, statistic_fn=lambda x_, y_: np.median(y_))
+```
+
+See `examples/quickstart_tutorial.py` for a complete, runnable walkthrough.
+
+## Segmentation
+
+Run any `robustkit.core` analysis independently across subgroups of a
+larger dataset, with automatic fallback to coarser groupings when a
+finer one is too small to analyze reliably:
+
+```python
+from robustkit import hierarchical_segment, apply_by_segment, model_stability_pct
+
+hierarchy = [["department", "level", "status"], ["level", "status"], ["status"]]
+segmented = hierarchical_segment(df, hierarchy, min_size=20)
+
+report = apply_by_segment(
+    segmented, segment_col="segment_id", x_col="age", y_col="value",
+    analysis_fn=model_stability_pct,
+)
+```
+
+`apply_by_segment` works with any function shaped like
+`analysis_fn(x, y, **kwargs) -> dict` -- built-in ones
+(`model_stability_pct`, `cook_impact`, `bca_bootstrap_ci`, ...) or your
+own. Only scalar values in the returned dict end up in the report
+table; segments below `min_points` are skipped rather than causing an
+error.
+
+## Feature ranking (information)
+
+Rank features by mutual information with a target, normalized by each
+feature's own entropy, and classify them into four quadrants:
+
+```python
+from robustkit import rank_features, quadrant_report, plot_feature_space
+
+ranking = rank_features(df, target="value")
+report = quadrant_report(df, target="value")   # adds a `quadrant` column
+plot_feature_space(df, target="value")          # same quadrants, visualized
+```
+
+`quadrant_report` and `plot_feature_space` always agree on quadrant
+assignment -- both route through the same thresholding logic.
+
+**Caveat:** default thresholds are the *median* mutual information /
+efficiency across the ranked features. With only a handful of
+features, this can put a genuinely weak feature in the same "high"
+half as a strong one, since roughly half of any list sits above its
+own median regardless of how large the actual gap is. Median
+thresholding becomes meaningful with a reasonably large feature set;
+for a handful of candidates, read the raw `mutual_information` /
+`information_efficiency` values directly rather than relying on the
+quadrant label alone.
+
+See `examples/information_tutorial.py` for a complete walkthrough.
+
+## Design principles
+
+- **One continuous x, one continuous y** at the core. This keeps every
+  function's output visually and numerically interpretable (a curve
+  you can plot, a band you can read).
+- **Diagnosis and action are separate steps.** `cooks_diagnostic`
+  flags candidates; `cook_impact` tells you whether removing them
+  actually changes anything.
+- **OLS is a reference point, not the enemy.** Comparing robust fits
+  against OLS is how you know whether robustness mattered at all.
+
+## License
+
+MIT -- see [LICENSE](LICENSE).

robustkit-0.0.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "robustkit"
+version = "0.0.1"
+description = "Practical tools for robust analysis of a single continuous relationship: trend fitting, stability checks, influence diagnostics, and bootstrap uncertainty."
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Mikael Lundqvist" }]
+requires-python = ">=3.10"
+dependencies = [
+    "numpy>=1.24",
+    "pandas>=2.0",
+    "scikit-learn>=1.3",
+    "statsmodels>=0.14",
+    "scipy>=1.10",
+    "matplotlib>=3.7",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[tool.setuptools.packages.find]
+include = ["robustkit*"]

robustkit-0.0.1/robustkit/__init__.py

@@ -0,0 +1,54 @@
+"""
+robustkit
+=========
+
+Practical tools for robust analysis of a single continuous relationship
+(y as a function of one continuous x), designed around one core idea:
+a conclusion that survives multiple fitting methods is more trustworthy
+than one that only holds under a single model.
+
+Modules:
+    robustkit.core          -- trend fitting, stability, diagnostics, uncertainty
+    robustkit.segmentation   -- hierarchical grouping, per-segment analysis
+    robustkit.information    -- mutual-information-based feature ranking
+"""
+
+from .core.trend import fit_huber_trend, fit_tukey_trend, fit_ols_trend, predict_trend
+from .core.stability import model_stability_pct
+from .core.diagnostics import cooks_diagnostic, cook_impact
+from .core.uncertainty import bootstrap_band, bca_bootstrap_ci
+from .core.consistency import check_row_integrity, compare_row_sets
+from .segmentation.hierarchy import hierarchical_segment, segment_sizes
+from .segmentation.apply import apply_by_segment
+from .information.entropy import entropy
+from .information.mutual_info import rank_features, information_efficiency
+from .information.quadrants import quadrant_report
+from .information.visualization import plot_feature_space, feature_map
+from .information.profile import profile, print_profile
+
+__all__ = [
+    "fit_huber_trend",
+    "fit_tukey_trend",
+    "fit_ols_trend",
+    "predict_trend",
+    "model_stability_pct",
+    "cooks_diagnostic",
+    "cook_impact",
+    "bootstrap_band",
+    "bca_bootstrap_ci",
+    "check_row_integrity",
+    "compare_row_sets",
+    "hierarchical_segment",
+    "segment_sizes",
+    "apply_by_segment",
+    "entropy",
+    "rank_features",
+    "information_efficiency",
+    "quadrant_report",
+    "plot_feature_space",
+    "feature_map",
+    "profile",
+    "print_profile",
+]
+
+__version__ = "0.0.1"

robustkit-0.0.1/robustkit/core/consistency.py

@@ -0,0 +1,33 @@
+"""
+Generic integrity checks, independent of any specific fitting method.
+"""
+
+
+def check_row_integrity(df, group_col):
+    total_rows = len(df)
+    n_missing_group = int(df[group_col].isna().sum())
+    grouped_rows = int(df.groupby(group_col, observed=True).size().sum())
+
+    return {
+        "total_rows": total_rows,
+        "rows_accounted_for": grouped_rows,
+        "rows_missing_group_label": n_missing_group,
+        "consistent": total_rows == grouped_rows + 0,
+    }
+
+
+def compare_row_sets(before_df, after_df, key_col):
+    before_keys = set(before_df[key_col])
+    after_keys = set(after_df[key_col])
+
+    dropped = before_keys - after_keys
+    added = after_keys - before_keys
+
+    return {
+        "n_before": len(before_keys),
+        "n_after": len(after_keys),
+        "n_dropped": len(dropped),
+        "n_added": len(added),
+        "dropped_keys": dropped,
+        "added_keys": added,
+    }

robustkit-0.0.1/robustkit/core/diagnostics.py

@@ -0,0 +1,94 @@
+"""
+Identify individually influential observations, and quantify how much
+they actually change the fitted trend if removed.
+
+cooks_diagnostic() answers "which points stand out?"
+cook_impact() answers "how much does it matter if we remove them?" --
+these are deliberately separate steps, since a flagged point is not
+automatically a point worth acting on.
+
+Cook's distance is computed here via plain OLS and the hat matrix
+(pure numpy/scikit-learn), so this module has no statsmodels
+dependency.
+"""
+
+import numpy as np
+
+from .trend import _design_matrix, fit_huber_trend, predict_trend
+
+
+def cooks_diagnostic(x, y, degree=2):
+    """
+    Compute Cook's distance for each observation, based on an OLS fit
+    of y ~ poly(x, degree). Flags points above the conventional 4/n
+    threshold.
+    """
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    n = len(y)
+
+    X, _ = _design_matrix(x, degree)
+    X_design = np.column_stack([np.ones(n), X])
+    p = X_design.shape[1]
+
+    beta, *_ = np.linalg.lstsq(X_design, y, rcond=None)
+    y_hat = X_design @ beta
+    residuals = y - y_hat
+
+    mse = np.sum(residuals ** 2) / (n - p)
+
+    Q, R = np.linalg.qr(X_design)
+    leverage = np.sum(Q ** 2, axis=1)
+    leverage = np.clip(leverage, 1e-12, 1 - 1e-12)
+
+    cooks_d = (residuals ** 2 / (p * mse)) * (leverage / (1 - leverage) ** 2)
+
+    threshold = 4 / n
+    flagged_indices = np.where(cooks_d > threshold)[0]
+
+    return {
+        "cooks_distance": cooks_d,
+        "leverage": leverage,
+        "threshold": threshold,
+        "flagged_indices": flagged_indices,
+    }
+
+
+def cook_impact(x, y, flagged_indices, degree=2, n_points=50):
+    """
+    Compare the Huber-fitted trend curve with and without the given
+    flagged observations, to quantify how much they actually pull the
+    curve.
+    """
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    grid = np.linspace(x.min(), x.max(), n_points)
+
+    full_fit = fit_huber_trend(x, y, degree=degree)
+    full_pred = predict_trend(full_fit, grid)
+
+    mask = np.ones(len(x), dtype=bool)
+    mask[np.asarray(flagged_indices, dtype=int)] = False
+
+    if mask.sum() < degree + 2:
+        raise ValueError(
+            "Too few remaining observations to fit a comparison curve "
+            "after excluding flagged points."
+        )
+
+    reduced_fit = fit_huber_trend(x[mask], y[mask], degree=degree)
+    reduced_pred = predict_trend(reduced_fit, grid)
+
+    denom = np.abs(full_pred)
+    denom[denom == 0] = np.nan
+    pct_change = np.abs(full_pred - reduced_pred) / denom * 100
+
+    return {
+        "grid": grid,
+        "with_flagged": full_pred,
+        "without_flagged": reduced_pred,
+        "pct_change": pct_change,
+        "median_pct_change": float(np.nanmedian(pct_change)),
+        "max_pct_change": float(np.nanmax(pct_change)),
+        "n_excluded": int((~mask).sum()),
+    }

robustkit-0.0.1/robustkit/core/stability.py

@@ -0,0 +1,48 @@
+"""
+Quantify how much a fitted trend curve changes depending on which
+fitting method (Huber, Tukey, or OLS) is used.
+
+The central idea: a curve shape that is nearly identical across all
+three methods is a more trustworthy conclusion than one that only
+appears under a single method.
+"""
+
+import numpy as np
+
+from .trend import fit_huber_trend, fit_tukey_trend, fit_ols_trend, predict_trend
+
+
+def model_stability_pct(x, y, degree=2, n_points=50):
+    """
+    Fit Huber, Tukey, and OLS trends to the same (x, y) data, evaluate
+    all three on a common grid, and report how far apart they are as a
+    percentage of the average predicted value at each grid point.
+    """
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    grid = np.linspace(x.min(), x.max(), n_points)
+
+    huber_fit = fit_huber_trend(x, y, degree=degree)
+    tukey_fit = fit_tukey_trend(x, y, degree=degree)
+    ols_fit = fit_ols_trend(x, y, degree=degree)
+
+    huber_pred = predict_trend(huber_fit, grid)
+    tukey_pred = predict_trend(tukey_fit, grid)
+    ols_pred = predict_trend(ols_fit, grid)
+
+    curves = np.vstack([huber_pred, tukey_pred, ols_pred])
+    spread = curves.max(axis=0) - curves.min(axis=0)
+    avg = np.abs(curves.mean(axis=0))
+    avg[avg == 0] = np.nan
+    pct_spread = spread / avg * 100
+
+    return {
+        "grid": grid,
+        "huber": huber_pred,
+        "tukey": tukey_pred,
+        "ols": ols_pred,
+        "pct_spread": pct_spread,
+        "median_pct_diff": float(np.nanmedian(pct_spread)),
+        "p95_pct_diff": float(np.nanpercentile(pct_spread, 95)),
+        "max_pct_diff": float(np.nanmax(pct_spread)),
+    }

robustkit-0.0.1/robustkit/core/trend.py

@@ -0,0 +1,86 @@
+"""
+Fit a trend curve -- y as a function of a single continuous x -- using
+three different loss functions: Huber, Tukey biweight, and ordinary
+least squares (OLS).
+
+All three share the same polynomial design matrix, so their fitted
+curves are directly comparable. OLS is included deliberately: if a
+robust method and OLS agree closely, that agreement is itself useful
+evidence that the conclusion is not driven by a handful of extreme
+points (see robustkit.core.stability).
+
+Note: statsmodels is only imported lazily, inside fit_tukey_trend and
+the statsmodels branch of predict_trend. Huber and OLS fitting (via
+scikit-learn) work without statsmodels installed at all.
+"""
+
+import numpy as np
+from sklearn.linear_model import HuberRegressor, LinearRegression
+from sklearn.preprocessing import PolynomialFeatures
+
+
+def _design_matrix(x, degree):
+    x = np.asarray(x, dtype=float).reshape(-1, 1)
+    poly = PolynomialFeatures(degree=degree, include_bias=False)
+    return poly.fit_transform(x), poly
+
+
+def fit_huber_trend(x, y, degree=2, epsilon=1.35, alpha=0.0001):
+    """
+    Fit y ~ poly(x, degree) using Huber loss.
+
+    epsilon controls the point at which the loss switches from
+    quadratic to linear (smaller = more aggressive downweighting of
+    outliers; 1.35 is the common default, tuned for ~95% efficiency
+    under normal errors).
+    """
+    X, poly = _design_matrix(x, degree)
+    model = HuberRegressor(epsilon=epsilon, alpha=alpha)
+    model.fit(X, y)
+    return {"model": model, "poly": poly, "kind": "sklearn"}
+
+
+def fit_tukey_trend(x, y, degree=2, c=4.685):
+    """
+    Fit y ~ poly(x, degree) using Tukey's biweight (redescending) loss
+    via statsmodels' robust linear model (RLM).
+
+    Unlike Huber, Tukey's loss fully suppresses the influence of very
+    extreme points rather than merely capping it -- useful when Huber
+    still seems pulled by a handful of severe outliers.
+
+    Requires statsmodels (imported lazily here).
+    """
+    import statsmodels.api as sm
+
+    X, poly = _design_matrix(x, degree)
+    X_sm = sm.add_constant(X)
+    model = sm.RLM(np.asarray(y, dtype=float), X_sm, M=sm.robust.norms.TukeyBiweight(c=c)).fit()
+    return {"model": model, "poly": poly, "kind": "statsmodels"}
+
+
+def fit_ols_trend(x, y, degree=2):
+    """
+    Fit y ~ poly(x, degree) using ordinary least squares. Serves as a
+    non-robust reference point, not a method to be discarded.
+    """
+    X, poly = _design_matrix(x, degree)
+    model = LinearRegression()
+    model.fit(X, y)
+    return {"model": model, "poly": poly, "kind": "sklearn"}
+
+
+def predict_trend(fit, x_new):
+    """
+    Predict y for new x values from a fit dict returned by
+    fit_huber_trend / fit_tukey_trend / fit_ols_trend.
+    """
+    x_new = np.asarray(x_new, dtype=float).reshape(-1, 1)
+    X_new = fit["poly"].transform(x_new)
+
+    if fit["kind"] == "statsmodels":
+        import statsmodels.api as sm
+        X_new = sm.add_constant(X_new, has_constant="add")
+        return np.asarray(fit["model"].predict(X_new))
+
+    return np.asarray(fit["model"].predict(X_new))