phenoforge 0.1.2__py3-none-any.whl

phenoforge/__init__.py

@@ -0,0 +1,41 @@
+"""phenoforge: phenomenological model-family bank + ensemble calibration engine.
+
+The package implements the BAPE methodology (Bootstrap-Aggregated Phenomenological
+Ensembles): instead of selecting ONE phenomenological model for a process dataset,
+fit MANY realizations (model families x parameter multistarts x bootstrap resamples)
+from a curated family bank and aggregate them into a calibrated ensemble with
+structural inclusion probabilities.
+
+Nearest prior art, cited and differentiated (see the Fragua research dossiers):
+- Fasel, Kutz, Brunton, Brunton 2022, Ensemble-SINDy, Proc. R. Soc. A 478:20210904,
+  DOI 10.1098/rspa.2021.0904 (bagging over generic term libraries).
+- Pinto, de Azevedo, Oliveira, von Stosch 2019, Bioprocess Biosyst. Eng. 42:1853-1865,
+  DOI 10.1007/s00449-019-02181-y (bootstrap-aggregated hybrid models, one family).
+- Duan, Ajami, Gao, Sorooshian 2007, Adv. Water Resour. 30:1371-1386,
+  DOI 10.1016/j.advwatres.2006.11.014 (BMA across model structures, hydrology).
+- Beven, Binley 1992, Hydrol. Process. 6:279-298 (GLUE); Beven 2006,
+  J. Hydrol. 320:18-36, DOI 10.1016/j.jhydrol.2005.07.007 (equifinality).
+- Yao, Vehtari, Simpson, Gelman 2018, Bayesian Anal. 13:917-1007,
+  DOI 10.1214/17-BA1091 (stacking in the M-open setting).
+
+The core is pure numpy/scipy (Pyodide-safe by design).
+"""
+
+__version__ = "0.01.002"
+
+from phenoforge.families.base import DataKind, FitResult, ModelFamily, Param
+from phenoforge.families.registry import get_family, list_families
+from phenoforge.fit.nls import fit_family
+from phenoforge.router import route
+
+__all__ = [
+    "DataKind",
+    "FitResult",
+    "ModelFamily",
+    "Param",
+    "__version__",
+    "fit_family",
+    "get_family",
+    "list_families",
+    "route",
+]

phenoforge/ensemble/__init__.py

@@ -0,0 +1,19 @@
+from phenoforge.ensemble.bape import BapeEnsemble, bape_fit
+from phenoforge.ensemble.bootstrap import BootstrapEnsemble, bootstrap_fit
+from phenoforge.ensemble.glue import GlueEnsemble, glue_fit
+from phenoforge.ensemble.ic import akaike_weights, averaged_prediction, select
+from phenoforge.ensemble.stacking import StackedEnsemble, stack_fit
+
+__all__ = [
+    "BapeEnsemble",
+    "BootstrapEnsemble",
+    "GlueEnsemble",
+    "StackedEnsemble",
+    "akaike_weights",
+    "averaged_prediction",
+    "bape_fit",
+    "bootstrap_fit",
+    "glue_fit",
+    "select",
+    "stack_fit",
+]

phenoforge/ensemble/bape.py

@@ -0,0 +1,172 @@
+"""BAPE: Bootstrap-Aggregated Phenomenological Ensembles (rung 6, the novel method).
+
+The random-forest recipe with phenomenological model families as base learners:
+
+- Each ensemble MEMBER sees (a) a bootstrap resample of the data (the bagging axis,
+  Breiman 1996) and (b) a random SUBSET of the family library (the feature-subsampling
+  analog applied to equation structure; in E-SINDy this is "library bagging" over
+  candidate terms, Fasel et al. 2022, DOI 10.1098/rspa.2021.0904; here it operates
+  over whole curated families).
+- Within its subset, the member fits every family and keeps the AICc-best fit (one
+  member = one fitted phenomenological model, the way one random-forest member is one
+  tree).
+- The ensemble aggregates member predictions (mean/median/quantiles) and reads
+  STRUCTURE off the member population: the inclusion probability of a family is the
+  fraction of members that selected it (the E-SINDy inclusion-probability readout
+  lifted from terms to families).
+
+Differentiation from prior art (all cited in the package docstring): E-SINDy bags
+sparse regressions over generic term libraries; Pinto et al. 2019 bags ONE hybrid
+structure; BMA/stacking weight given models without resampling; GLUE keeps parameter
+sets of given structures. BAPE crosses the family axis with the bootstrap axis.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from phenoforge.ensemble.bootstrap import bootstrap_indices
+from phenoforge.families.base import FitResult, ModelFamily
+from phenoforge.fit.nls import fit_family
+
+
+@dataclass
+class BapeMember:
+    family: ModelFamily
+    fit: FitResult
+    boot_index: int
+    subset_keys: tuple[str, ...]
+
+
+@dataclass
+class BapeEnsemble:
+    families: tuple[ModelFamily, ...]
+    members: list[BapeMember]
+    requested: int
+    meta: dict = field(default_factory=dict)
+
+    @property
+    def kept(self) -> int:
+        return len(self.members)
+
+    def member_predictions(self, x: np.ndarray) -> np.ndarray:
+        return np.stack([m.family.predict(x, m.fit.theta) for m in self.members])
+
+    def predict(self, x: np.ndarray, aggregate: str = "mean") -> np.ndarray:
+        m = self.member_predictions(x)
+        if aggregate == "mean":
+            return m.mean(axis=0)
+        if aggregate == "median":
+            return np.median(m, axis=0)
+        raise ValueError("aggregate must be 'mean' or 'median'")
+
+    def quantiles(
+        self, x: np.ndarray, qs: tuple[float, ...] = (0.05, 0.25, 0.5, 0.75, 0.95)
+    ) -> np.ndarray:
+        return np.quantile(self.member_predictions(x), qs, axis=0)
+
+    def inclusion_probabilities(self) -> dict[str, float]:
+        """P(family selected | member), the structural-uncertainty readout.
+
+        Normalizing by the number of members in which the family was OFFERED (it was
+        in the member's random subset) rather than by all members, so a family is not
+        penalized for having been absent from a member's menu.
+        """
+        offered: dict[str, int] = {f.key: 0 for f in self.families}
+        selected: dict[str, int] = {f.key: 0 for f in self.families}
+        for m in self.members:
+            for key in m.subset_keys:
+                offered[key] += 1
+            selected[m.family.key] += 1
+        return {
+            k: (selected[k] / offered[k]) if offered[k] > 0 else 0.0 for k in offered
+        }
+
+    def selection_shares(self) -> dict[str, float]:
+        """Fraction of members won by each family (sums to 1)."""
+        shares: dict[str, int] = {f.key: 0 for f in self.families}
+        for m in self.members:
+            shares[m.family.key] += 1
+        total = max(self.kept, 1)
+        return {k: v / total for k, v in shares.items()}
+
+
+def bape_fit(
+    families: tuple[ModelFamily, ...],
+    x: np.ndarray,
+    y: np.ndarray,
+    *,
+    n_members: int = 200,
+    subset_size: int | None = None,
+    seed: int = 0,
+    block: int | None = None,
+    n_starts: int = 6,
+    criterion: str = "aicc",
+) -> BapeEnsemble:
+    """Fit a BAPE ensemble over the bank.
+
+    subset_size defaults to ceil(sqrt(len(families))) + 1, the random-forest
+    heuristic adapted to small libraries (guarantees >= 2 families per member when
+    the bank has >= 2).
+    """
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    n = y.shape[0]
+    n_fam = len(families)
+    if n_fam == 0:
+        raise ValueError("empty family bank")
+    if subset_size is None:
+        subset_size = min(n_fam, int(np.ceil(np.sqrt(n_fam))) + 1)
+    subset_size = max(1, min(subset_size, n_fam))
+
+    rng = np.random.default_rng(seed)
+    idx = bootstrap_indices(n, n_members, rng, block=block)
+
+    members: list[BapeMember] = []
+    for b in range(n_members):
+        xb, yb = x[idx[b]], y[idx[b]]
+        chosen = rng.choice(n_fam, size=subset_size, replace=False)
+        subset = tuple(families[int(c)] for c in chosen)
+        fits: list[tuple[ModelFamily, FitResult]] = []
+        for j, fam in enumerate(subset):
+            res = fit_family(
+                fam, xb, yb, n_starts=n_starts, seed=seed + 104729 * (b + 1) + j
+            )
+            if res.success and np.isfinite(res.rss):
+                fits.append((fam, res))
+        # coherent per-member criterion: preferred unless it is +inf for every
+        # candidate in this member's menu (tiny resamples), then BIC for all
+        crit = criterion
+        if fits and not any(np.isfinite(getattr(r, criterion)) for _, r in fits):
+            crit = "bic"
+        best: tuple[ModelFamily, FitResult] | None = None
+        best_val = float("inf")
+        for fam, res in fits:
+            val = getattr(res, crit)
+            if np.isfinite(val) and val < best_val:
+                best_val = val
+                best = (fam, res)
+        if best is not None:
+            members.append(
+                BapeMember(
+                    family=best[0],
+                    fit=best[1],
+                    boot_index=b,
+                    subset_keys=tuple(f.key for f in subset),
+                )
+            )
+
+    return BapeEnsemble(
+        families=families,
+        members=members,
+        requested=n_members,
+        meta={
+            "subset_size": subset_size,
+            "criterion": criterion,
+            "seed": seed,
+            "block": block,
+            "n_starts": n_starts,
+        },
+    )

phenoforge/ensemble/bootstrap.py

@@ -0,0 +1,98 @@
+"""Bootstrap-aggregated fits of one family (rung 5 substrate).
+
+Paired (case) bootstrap for independent observations and a moving-block bootstrap for
+serially correlated data (plant time series). Aggregation by mean (bagging, Breiman
+1996) or median (bragging, the E-SINDy usage: Fasel et al. 2022,
+DOI 10.1098/rspa.2021.0904). The single-family bootstrap generalizes the mechanism of
+Pinto et al. 2019 (DOI 10.1007/s00449-019-02181-y) beyond one hybrid structure.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from phenoforge.families.base import FitResult, ModelFamily
+from phenoforge.fit.nls import fit_family
+
+
+def bootstrap_indices(
+    n: int, n_boot: int, rng: np.random.Generator, block: int | None = None
+) -> np.ndarray:
+    """(n_boot, n) resample index matrix; block > 1 switches to moving-block."""
+    if block is None or block <= 1:
+        return rng.integers(0, n, size=(n_boot, n))
+    n_blocks = int(np.ceil(n / block))
+    starts = rng.integers(0, max(n - block + 1, 1), size=(n_boot, n_blocks))
+    idx = (starts[:, :, None] + np.arange(block)[None, None, :]).reshape(n_boot, -1)
+    return idx[:, :n]
+
+
+@dataclass
+class BootstrapEnsemble:
+    """Fitted bootstrap fleet of ONE family."""
+
+    family: ModelFamily
+    fits: list[FitResult]
+    kept: int
+    requested: int
+    meta: dict = field(default_factory=dict)
+
+    def thetas(self) -> np.ndarray:
+        return np.stack([f.theta for f in self.fits])
+
+    def member_predictions(self, x: np.ndarray) -> np.ndarray:
+        """(n_members, n_x) member prediction matrix."""
+        return np.stack([self.family.predict(x, f.theta) for f in self.fits])
+
+    def predict(self, x: np.ndarray, aggregate: str = "mean") -> np.ndarray:
+        m = self.member_predictions(x)
+        if aggregate == "mean":
+            return m.mean(axis=0)
+        if aggregate == "median":
+            return np.median(m, axis=0)
+        raise ValueError("aggregate must be 'mean' (bagging) or 'median' (bragging)")
+
+    def quantiles(
+        self, x: np.ndarray, qs: tuple[float, ...] = (0.05, 0.25, 0.5, 0.75, 0.95)
+    ) -> np.ndarray:
+        return np.quantile(self.member_predictions(x), qs, axis=0)
+
+
+def bootstrap_fit(
+    family: ModelFamily,
+    x: np.ndarray,
+    y: np.ndarray,
+    *,
+    n_boot: int = 200,
+    seed: int = 0,
+    block: int | None = None,
+    n_starts: int = 6,
+) -> BootstrapEnsemble:
+    """Fit `family` on n_boot bootstrap resamples of (x, y).
+
+    Members whose fit fails (non-finite RSS) are dropped and COUNTED: `kept` vs
+    `requested` is part of the record, never silently equalized.
+    """
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    n = y.shape[0]
+    rng = np.random.default_rng(seed)
+    idx = bootstrap_indices(n, n_boot, rng, block=block)
+
+    fits: list[FitResult] = []
+    for b in range(n_boot):
+        xb, yb = x[idx[b]], y[idx[b]]
+        res = fit_family(family, xb, yb, n_starts=n_starts, seed=seed + 7919 * (b + 1))
+        if res.success and np.isfinite(res.rss):
+            res.meta["boot_index"] = b
+            fits.append(res)
+
+    return BootstrapEnsemble(
+        family=family,
+        fits=fits,
+        kept=len(fits),
+        requested=n_boot,
+        meta={"block": block, "seed": seed},
+    )

phenoforge/ensemble/glue.py

@@ -0,0 +1,102 @@
+"""GLUE: generalized likelihood uncertainty estimation (rung 4).
+
+Monte Carlo sampling of parameter sets inside the physical bounds, retention of the
+"behavioural" sets above a likelihood threshold, and likelihood-weighted predictive
+quantiles. The equifinality readout: many parameter sets (and structures) reproduce
+the data comparably well, and keeping them IS the uncertainty statement.
+
+Primary sources: Beven and Binley 1992, Hydrol. Process. 6, 279-298; Beven 2006,
+J. Hydrol. 320, 18-36, DOI 10.1016/j.jhydrol.2005.07.007; Beven and Binley 2014,
+Hydrol. Process. 28, 5897-5918, DOI 10.1002/hyp.10082. GLUE weights are an informal
+likelihood by construction; that caveat ships with every GLUE artifact
+(Stedinger et al. 2008, DOI 10.1029/2008WR006822).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from phenoforge.families.base import ModelFamily
+
+
+@dataclass
+class GlueEnsemble:
+    family: ModelFamily
+    thetas: np.ndarray          # (n_behavioural, k)
+    likelihoods: np.ndarray     # (n_behavioural,) normalized to sum 1
+    threshold: float
+    n_sampled: int
+
+    @property
+    def n_behavioural(self) -> int:
+        return int(self.thetas.shape[0])
+
+    def member_predictions(self, x: np.ndarray) -> np.ndarray:
+        return np.stack([self.family.predict(x, t) for t in self.thetas])
+
+    def predict(self, x: np.ndarray) -> np.ndarray:
+        """Likelihood-weighted mean prediction."""
+        m = self.member_predictions(x)
+        return np.einsum("m,mn->n", self.likelihoods, m)
+
+    def quantiles(self, x: np.ndarray, qs: tuple[float, ...] = (0.05, 0.5, 0.95)) -> np.ndarray:
+        """Likelihood-weighted predictive quantiles per x point."""
+        m = self.member_predictions(x)  # (M, N)
+        order = np.argsort(m, axis=0)
+        sorted_m = np.take_along_axis(m, order, axis=0)
+        w = self.likelihoods[order]
+        cw = np.cumsum(w, axis=0)
+        cw /= cw[-1:, :]
+        out = np.empty((len(qs), m.shape[1]))
+        for j, q in enumerate(qs):
+            hit = np.argmax(cw >= q, axis=0)
+            out[j] = sorted_m[hit, np.arange(m.shape[1])]
+        return out
+
+
+def nash_sutcliffe(y: np.ndarray, yhat: np.ndarray) -> float:
+    """Nash-Sutcliffe efficiency, the customary GLUE informal likelihood."""
+    y = np.asarray(y, dtype=float)
+    denom = float(np.sum((y - y.mean()) ** 2))
+    if denom == 0.0:
+        return float("-inf")
+    return 1.0 - float(np.sum((y - yhat) ** 2)) / denom
+
+
+def glue_fit(
+    family: ModelFamily,
+    x: np.ndarray,
+    y: np.ndarray,
+    *,
+    n_samples: int = 20000,
+    threshold: float = 0.0,
+    seed: int = 0,
+) -> GlueEnsemble:
+    """Sample uniform-in-bounds parameter sets; keep NSE > threshold as behavioural.
+
+    Weights are shifted NSE (informal likelihood), normalized over the behavioural
+    set. An empty behavioural set is returned EMPTY (n_behavioural == 0), which is a
+    valid scientific verdict, not an error.
+    """
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    rng = np.random.default_rng(seed)
+    lo, hi = family.bounds
+    thetas = lo + rng.random((n_samples, family.k)) * (hi - lo)
+
+    nse = np.array([nash_sutcliffe(y, family.predict(x, t)) for t in thetas])
+    keep = nse > threshold
+    kept = thetas[keep]
+    scores = nse[keep] - threshold
+    total = float(scores.sum())
+    lik = scores / total if total > 0 else scores
+
+    return GlueEnsemble(
+        family=family,
+        thetas=kept,
+        likelihoods=lik,
+        threshold=threshold,
+        n_sampled=n_samples,
+    )

phenoforge/ensemble/ic.py

@@ -0,0 +1,80 @@
+"""Information-criterion selection and model averaging across a family bank.
+
+Rungs 2 and 3 of the Fragua ladder:
+- select(): the better current practice (AICc/BIC winner-take-all).
+- akaike_weights() + averaged_prediction(): keep the WHOLE family and average with
+  IC weights (multimodel inference, Burnham and Anderson 2004,
+  DOI 10.1177/0049124104268644).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from phenoforge.families.base import FitResult, ModelFamily
+
+
+def _criterion_values(results: list[FitResult], criterion: str) -> np.ndarray:
+    if criterion not in ("aic", "aicc", "bic"):
+        raise ValueError("criterion must be one of aic, aicc, bic")
+    return np.array([getattr(r, criterion) for r in results], dtype=float)
+
+
+def choose_criterion(results: list[FitResult], preferred: str = "aicc") -> str:
+    """Pick ONE coherent criterion for a bank on a given dataset.
+
+    AICc is preferred, but its small-sample correction is undefined (+inf) when
+    n <= p + 1; on very short series that hits EVERY family. Mixing criteria
+    across families would be incoherent, so: use `preferred` when at least one
+    successful fit has a finite value, else fall back to BIC for the whole bank
+    (finite whenever the fit itself is finite).
+    """
+    vals = _criterion_values(results, preferred)
+    ok = [np.isfinite(v) and r.success for v, r in zip(vals, results, strict=True)]
+    if any(ok):
+        return preferred
+    return "bic"
+
+
+def select(results: list[FitResult], criterion: str = "aicc") -> FitResult:
+    """Winner-take-all selection by an information criterion."""
+    vals = _criterion_values(results, criterion)
+    if not np.isfinite(vals).any():
+        raise ValueError("no finite criterion value in the bank (all fits failed)")
+    return results[int(np.nanargmin(np.where(np.isfinite(vals), vals, np.nan)))]
+
+
+def akaike_weights(results: list[FitResult], criterion: str = "aicc") -> np.ndarray:
+    """Normalized exp(-delta/2) weights over the bank.
+
+    Non-finite criteria (failed or over-parameterized fits) receive weight 0; the
+    remainder renormalizes. This is the honest treatment: an unfittable member does
+    not silently disappear from the record, it carries zero weight.
+    """
+    vals = _criterion_values(results, criterion)
+    finite = np.isfinite(vals)
+    w = np.zeros_like(vals)
+    if finite.any():
+        d = vals[finite] - np.min(vals[finite])
+        e = np.exp(-0.5 * d)
+        w[finite] = e / np.sum(e)
+    return w
+
+
+def averaged_prediction(
+    families: tuple[ModelFamily, ...],
+    results: list[FitResult],
+    x: np.ndarray,
+    criterion: str = "aicc",
+) -> tuple[np.ndarray, np.ndarray]:
+    """IC-weight model-averaged prediction over the bank.
+
+    Returns (y_avg, weights) with weights aligned to `families`/`results` order.
+    """
+    if len(families) != len(results):
+        raise ValueError("families and results disagree in length")
+    w = akaike_weights(results, criterion)
+    preds = np.stack(
+        [fam.predict(x, res.theta) for fam, res in zip(families, results, strict=True)]
+    )
+    return np.einsum("m,mn->n", w, preds), w

phenoforge/ensemble/stacking.py

@@ -0,0 +1,96 @@
+"""Stacking: cross-validated convex combination of family predictions (rung 7).
+
+Learns nonnegative weights summing to 1 that minimize the K-fold out-of-fold squared
+error of the combined prediction; the super-learner recipe restricted to the convex
+simplex. Primary sources: Wolpert 1992, Neural Networks 5, 241-259; van der Laan,
+Polley, Hubbard 2007, Stat. Appl. Genet. Mol. Biol. 6(1):25; Yao, Vehtari, Simpson,
+Gelman 2018, Bayesian Anal. 13, 917-1007, DOI 10.1214/17-BA1091 (why stacking is the
+robust combination in the M-open setting every industrial family bank lives in).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+from scipy.optimize import nnls
+
+from phenoforge.families.base import ModelFamily
+from phenoforge.fit.nls import fit_family
+
+
+def kfold_indices(n: int, k: int, rng: np.random.Generator) -> list[np.ndarray]:
+    perm = rng.permutation(n)
+    return [perm[i::k] for i in range(k)]
+
+
+def simplex_weights_for(oof: np.ndarray, y: np.ndarray) -> np.ndarray:
+    """Nonnegative least squares on the out-of-fold matrix, renormalized to sum 1.
+
+    NNLS + renormalization is the standard practical solver for simplex-constrained
+    stacking; exact simplex QP differs negligibly for well-scaled problems.
+    """
+    w, _ = nnls(oof, y)
+    s = w.sum()
+    if s <= 0:
+        # Degenerate: no member helps; fall back to uniform (honest, recorded upstream).
+        return np.full(oof.shape[1], 1.0 / oof.shape[1])
+    return w / s
+
+
+@dataclass
+class StackedEnsemble:
+    families: tuple[ModelFamily, ...]
+    thetas: list[np.ndarray]     # full-data refit per family
+    weights: np.ndarray          # (n_families,) convex
+    oof_rmse: float              # out-of-fold RMSE of the stack
+
+    def predict(self, x: np.ndarray) -> np.ndarray:
+        preds = np.stack(
+            [f.predict(x, t) for f, t in zip(self.families, self.thetas, strict=True)]
+        )
+        return np.einsum("m,mn->n", self.weights, preds)
+
+
+def stack_fit(
+    families: tuple[ModelFamily, ...],
+    x: np.ndarray,
+    y: np.ndarray,
+    *,
+    k_folds: int = 5,
+    seed: int = 0,
+    n_starts: int = 8,
+) -> StackedEnsemble:
+    """K-fold stacking over the bank.
+
+    Each family is fit on every training fold; its out-of-fold predictions fill one
+    column of the OOF matrix; weights solve the simplex-constrained least squares on
+    that matrix; final member parameters are full-data refits.
+    """
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    n = y.shape[0]
+    if n < 2 * k_folds:
+        k_folds = max(2, n // 2)
+    rng = np.random.default_rng(seed)
+    folds = kfold_indices(n, k_folds, rng)
+
+    oof = np.zeros((n, len(families)))
+    for j, fam in enumerate(families):
+        for f_idx, test_idx in enumerate(folds):
+            train_mask = np.ones(n, dtype=bool)
+            train_mask[test_idx] = False
+            res = fit_family(
+                fam, x[train_mask], y[train_mask],
+                n_starts=n_starts, seed=seed + 101 * j + f_idx,
+            )
+            oof[test_idx, j] = fam.predict(x[test_idx], res.theta)
+
+    w = simplex_weights_for(oof, y)
+    oof_rmse = float(np.sqrt(np.mean((y - oof @ w) ** 2)))
+
+    thetas = [
+        fit_family(fam, x, y, n_starts=n_starts, seed=seed + 977 * j).theta
+        for j, fam in enumerate(families)
+    ]
+    return StackedEnsemble(families=families, thetas=thetas, weights=w, oof_rmse=oof_rmse)

phenoforge/families/__init__.py

@@ -0,0 +1,12 @@
+from phenoforge.families.base import DataKind, FitResult, ModelFamily, Param, Reference
+from phenoforge.families.registry import get_family, list_families
+
+__all__ = [
+    "DataKind",
+    "FitResult",
+    "ModelFamily",
+    "Param",
+    "Reference",
+    "get_family",
+    "list_families",
+]