structboost 0.1.2__tar.gz → 0.2.0__tar.gz

structboost-0.2.0/CHANGELOG.md

@@ -0,0 +1,136 @@
+## Changelog
+
+Releases follow [semantic versioning](https://semver.org). While the project is
+pre-1.0, a minor bump may break API.
+
+### [0.2.0] - 2026-08-05
+
+The boosting loop got faster without changing what it computes. Measured
+end-to-end on real preprocessed scRNA-seq (20,000 cells, `latent_dim=10`):
+**1.86x at p=2,000, 2.20x at p=3,000, 1.80x at p=8,000**, and 1.46x on a
+batch-integrated fit with 20 covariate dummies.
+
+**This is not a methodological improvement.** Across eighteen configurations —
+plain, all three `batch_integration_mode` values, flat and per-dimension
+`mandatory_genes`, `balance_obs`, `split_softmax`, both disentanglement methods,
+`standardize_targets`, frozen/anchored/zero-dimension transfers and both
+stability modes — the selected gene set is *identical* and the reconstruction
+loss agrees to the sixth decimal. Nothing here recovers a marker that was
+previously missed. What it buys is more iterations and more stability runs for
+the same budget, which is what a method whose encoder support keeps drifting
+actually needs.
+
+Stability selection benefits too, and for the default `n_runs=300` that is the
+larger absolute saving: **1.79–1.88x** for iteration mode and **1.31–1.39x** for
+subsample mode at p=2,000–3,000, with peak memory during a subsample run falling
+from 360 MB to 5 MB at p=3,000 — that figure is exactly the float64 copy of the
+expression matrix described below. Subsample mode gains less by construction:
+every run draws a different subset of cells, so its column norms genuinely change
+and cannot be hoisted, and it uses the lazy column cache rather than the full
+matrix.
+
+Precomputing the covariance matrix *inside* subsample mode was measured and
+rejected. It runs 3.07x faster at p=2,000 and 2.69x at p=3,000, but 0.73–0.85x
+**slower** from p=6,000 upwards: the number of distinct columns a subsample
+selects stays roughly flat as p grows, so the full p x p product stops paying for
+itself. A memory guard cannot separate those cases — the 800 MB matrix at
+p=10,000 fits comfortably and still loses — so that path stays lazy at every p.
+
+`boosting_precompute_covcache` now defaults to `"auto"` and applies to every
+boosting path, including iteration-mode stability selection, which previously
+ignored the setting entirely. `"auto"` builds the full p x p covariance matrix
+whenever it fits a conservative share of system memory; `True` and `False` are
+still honoured exactly, and the resolved decision is recorded in
+`adata.uns["bae"]["boosting_precompute_covcache"]`.
+
+The flag was documented as a memory-versus-recomputation trade, which undersold
+it. Building all `p` columns at once is one compute-bound matrix product near
+hardware peak; fetching them one at a time is a sequence of memory-bound
+matrix-vector products. Precomputing wins from roughly `p/59` distinct selected
+features onwards — a threshold a fit passes in its first iteration.
+
+Three quantities that never change were being recomputed. `col_norms_sq` was
+rebuilt on every training iteration although the design matrix is fixed for the
+whole fit, allocating a full-size temporary each time; the mandatory-covariate
+block was rebuilt on every *boosting step* although it depends only on the
+target; and the covariance cache's NaN check re-scanned columns that had already
+been verified. The starting residual correlations are now formed for all latent
+dimensions in one matrix product rather than one per dimension.
+
+A float64 target passed against float32 predictors used to make NumPy promote
+the *design matrix*, materializing a full float64 copy — measured 2.1x slower,
+and it silently produced a different answer. The target is now aligned to the
+predictors instead.
+
+The three entry points to the same boosting problem ran at two different
+precisions: `fit` in float32, both stability paths in float64 on top of a
+float32 copy they had already made. They now agree on float32, which removes two
+full-size copies of the expression matrix. The precision this gives up was
+measured at about one gene in 380 — far inside the run-to-run support variation
+this method documents for itself.
+
+Results are **not bit-identical to 0.1.2**. Coefficients move by ~1e-6 relative
+and the selected support does not change; a fixed seed no longer reproduces
+0.1.2 output exactly.
+
+### [0.1.2] - 2026-08-03
+
+Project metadata gains `Documentation` and `Changelog` links. PyPI renders
+`project.urls` as the sidebar next to the project description, and it carried
+only the repository and the issue tracker — so the documentation site, where
+every substantive explanation lives, was reachable from the README body but not
+from the navigation beside it. Both targets are verified live.
+
+As with 0.1.1, nothing in the package changed: `project.urls` reaches users only
+through an upload, so correcting it in the repository has no effect until a
+release carries it.
+
+### [0.1.1] - 2026-08-03
+
+A metadata release. No code in `structboost` changed; every difference is in
+what the package says about itself.
+
+The PyPI page is the reason for it. A project's long description is baked into
+the uploaded artifacts and is immutable per release, so 0.1.0 shipped with a
+README announcing "Not on PyPI yet" and directing readers to a pinned TestPyPI
+install. Correcting the file in git does not touch the published page — only a
+new release does. A `0.1.0.post1` would have expressed "packaging only" more
+precisely, but post-releases are handled inconsistently by downstream tooling
+and the versioning policy here is plain `MAJOR.MINOR.PATCH`.
+
+Python 3.13 is tested and advertised. `requires-python = ">=3.10"` never had an
+upper bound, so pip already installed on 3.13 while the CI matrix stopped at
+3.12 — support permitted but never exercised. The matrix now covers it, and the
+classifier list says what the requirement already allowed. 3.14 is left out
+until the `[bae]` extra's wheels are dependably available there.
+
+`CITATION.cff` gains `version` and `date-released`, which a citation file for a
+released version cannot do without, plus a `url` for the documentation site.
+
+### [0.1.0] - 2026-07-31
+
+First public release.
+
+Batch integration is one argument. `BAE.fit(batch_key=...)` names the covariate,
+following scVI's spelling, and `batch_integration_mode` chooses between
+`"decoder"`, `"encoder"` and `"both"`, defaulting to `"both"`. No `batch_key`
+means no integration, and naming a mode without one raises rather than quietly
+integrating nothing.
+
+`"encoder"` names the half of the model the mechanism protects, not a tensor the
+covariate is fed to: it enters the boosting design as a mandatory regressor so
+gene selection is not confounded by it. `transform` remains gene-only and needs
+no covariate labels under any mode.
+
+The ridge that stabilizes near-collinear covariates is `BAEConfig.nuisance_ridge`.
+It is a numerical knob rather than a modelling one, so it sits with the other
+algorithm settings.
+
+The `test` extra pulls the runtime dependencies. The sdist carries `tests/` and
+`conftest.py` so that downstream packagers can run the suite at build time, and
+with pytest alone that did not work: 360 of the 411 test functions sit behind an
+`importorskip` for torch or anndata, so `pip install .[test] && pytest` ran ~51
+tests, skipped the rest and reported success. Installing `[test]` now brings in
+`[bae]`, so a green build means the suite actually ran. Documenting the
+requirement in `CONTRIBUTING.md` instead was rejected, because the reader who
+needs it is an automated build script rather than a person.

{structboost-0.1.2 → structboost-0.2.0}/CITATION.cff

@@ -2,8 +2,8 @@ cff-version: 1.2.0
 message: "If you use structboost in your research, please cite it."
 title: "structboost"
 type: software
-version: "0.1.2"
-date-released: "2026-08-03"
+version: "0.2.0"
+date-released: "2026-08-05"
 license: MIT
 authors:
   - family-names: Brunn

{structboost-0.1.2 → structboost-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structboost
-Version: 0.1.2
+Version: 0.2.0
 Summary: Boosting Autoencoders (BAE) and componentwise L2 boosting utilities for scverse-style workflows.
 Project-URL: Homepage, https://github.com/NiklasBrunn/structboost
 Project-URL: Documentation, https://niklasbrunn.github.io/structboost

{structboost-0.1.2 → structboost-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "structboost"
-version = "0.1.2"
+version = "0.2.0"
 description = "Boosting Autoencoders (BAE) and componentwise L2 boosting utilities for scverse-style workflows."
 readme = "README.md"
 license = { file = "LICENSE" }

{structboost-0.1.2 → structboost-0.2.0}/src/structboost/__init__.py

@@ -16,7 +16,7 @@ from ._annotation import (
     extract_gene_rankings,
     write_annotations_to_h5ad,
 )
-from ._boosting import AllboostHistory, allboost
+from ._boosting import AllboostHistory, allboost, column_norms_sq
 from ._io import looks_like_ensembl, read_encoder_weights, write_encoder_weights
 from ._simulation import SimulationResult, sim_scrnaseq_anndata, sim_scrnaseq_data
 from ._stability import StabilitySelectionResult, stability_selection
@@ -51,6 +51,7 @@ __all__ = [
     "StabilitySelectionResult",
     "TrainingReport",
     "allboost",
+    "column_norms_sq",
     "compute_covariance_cache",
     "encode_obs_covariates",
     "export_interactive_html",

{structboost-0.1.2 → structboost-0.2.0}/src/structboost/_boosting.py

@@ -12,32 +12,23 @@ from numpy.typing import NDArray
 _CovarianceCache = NDArray[np.floating] | dict[int, NDArray[np.float64]]
 
 
-def _calc_unibeta(
-    x: NDArray[np.floating],
-    y: NDArray[np.floating],
-    col_norms_sq: NDArray[np.floating] | None = None,
-) -> tuple[NDArray[np.floating], NDArray[np.floating]]:
-    """Univariate regression coefficients and column squared norms.
+def column_norms_sq(sourcemat: NDArray[np.floating]) -> NDArray[np.floating]:
+    """Squared column norms ``||x_j||^2`` of the boosting design matrix.
 
-    Parameters
-    ----------
-    x : ndarray of shape (n_samples, n_features)
-        Predictor matrix.
-    y : ndarray of shape (n_samples,)
-        Target vector.
-    col_norms_sq : ndarray of shape (n_features,), optional
-        Pre-computed squared column norms ||x_j||^2. If None, computed internally.
+    Exposed so a caller that invokes :func:`allboost` repeatedly against the
+    *same* ``sourcemat`` -- which is what :meth:`structboost.BAE.fit` does, once
+    per training iteration -- can compute this once and pass it back in. It is
+    otherwise recomputed on every call, an O(n*p) pass that also allocates a full
+    ``(n_samples, n_features)`` temporary.
 
-    Returns
-    -------
-    unibeta : ndarray of shape (n_features,)
-        Coefficients beta_j = (x_j'y) / (x_j'x_j).
-    col_norms_sq : ndarray of shape (n_features,)
-        Squared column norms ||x_j||^2 (returned for reuse).
+    Using this helper rather than open-coding the expression is what guarantees a
+    hoisted value is bit-for-bit the one ``allboost`` would have computed itself.
+
+    ``einsum`` rather than ``(sourcemat**2).sum(axis=0)``: the latter materializes
+    a full ``(n_samples, n_features)`` squared copy, 1.4 GB at 60k x 6k, purely to
+    reduce it away again.
     """
-    if col_norms_sq is None:
-        col_norms_sq = (x**2).sum(axis=0)
-    return (x.T @ y) / col_norms_sq, col_norms_sq
+    return np.einsum("ij,ij->j", sourcemat, sourcemat)
 
 
 @dataclass
@@ -106,13 +97,41 @@ def _validate_mandatory_features(
     return validated
 
 
+class _MandatoryBlock:
+    """The per-target constants of the mandatory pre-step.
+
+    ``mand_idx`` is fixed for the whole of a target's boosting run, so the
+    covariance columns of the mandatory features, the Gram submatrix among them
+    and the ridge penalty do not change between steps -- only the right-hand side
+    does. Building them once per target instead of once per *step* is what this
+    exists for: the ``column_stack`` alone costs ~270 ms per training iteration at
+    20 mandatory features and p=4000, repeated ``stepno`` times for nothing.
+    """
+
+    __slots__ = ("cov", "lhs", "penalty")
+
+    def __init__(
+        self,
+        mand_idx: NDArray[np.intp],
+        col_norms_sq: NDArray[np.floating],
+        get_covariance_column: Callable[[int], NDArray[np.floating]],
+        ridge: NDArray[np.float64],
+    ) -> None:
+        self.cov = np.column_stack([get_covariance_column(int(j)) for j in mand_idx])
+        self.penalty = ridge[mand_idx] * col_norms_sq[mand_idx]
+        # The solve's left-hand side is constant across steps too. Deliberately
+        # kept as a matrix rather than a factorization: `np.linalg.solve` is
+        # O(n_mandatory^3) and therefore free next to the block construction,
+        # while swapping in a Cholesky would change results in the last bits.
+        self.lhs = self.cov[mand_idx] + np.diag(self.penalty)
+
+
 def _mandatory_prestep(
     mand_idx: NDArray[np.intp],
     actualnom: NDArray[np.floating],
     beta: NDArray[np.floating],
     col_norms_sq: NDArray[np.floating],
-    get_covariance_column: Callable[[int], NDArray[np.floating]],
-    ridge: NDArray[np.float64],
+    block: _MandatoryBlock,
     target_index: int = 0,
 ) -> tuple[NDArray[np.floating], NDArray[np.floating]]:
     """Joint mandatory update, optionally ridge-stabilized.
@@ -123,15 +142,12 @@ def _mandatory_prestep(
     if mand_idx.size == 0:
         return actualnom, beta
 
-    mandatory_cov = np.column_stack([get_covariance_column(int(j)) for j in mand_idx])
-    c_mm = mandatory_cov[mand_idx]
-    penalty = ridge[mand_idx] * col_norms_sq[mand_idx]
     # Include the derivative of the penalty at the current coefficient. Without
     # this term, repeatedly applying a ridge pre-step would converge back to the
     # unpenalized OLS solution as boosting proceeds.
-    nom_mand = actualnom[mand_idx] * col_norms_sq[mand_idx] - penalty * beta[mand_idx]
+    nom_mand = actualnom[mand_idx] * col_norms_sq[mand_idx] - block.penalty * beta[mand_idx]
     try:
-        gamma_mand = np.linalg.solve(c_mm + np.diag(penalty), nom_mand)
+        gamma_mand = np.linalg.solve(block.lhs, nom_mand)
     except np.linalg.LinAlgError as exc:
         # Deliberately not falling back to a pseudo-inverse or auto-adding ridge:
         # either silently fits a different model than the caller specified.
@@ -145,7 +161,7 @@ def _mandatory_prestep(
             "is not applied automatically."
         ) from exc
     beta[mand_idx] += gamma_mand
-    actualnom -= (mandatory_cov @ gamma_mand) / col_norms_sq
+    actualnom -= (block.cov @ gamma_mand) / col_norms_sq
 
     return actualnom, beta
 
@@ -159,6 +175,7 @@ def allboost(
     mandatory_ridge: float | NDArray[np.floating] = 0.0,
     beta_init: NDArray[np.floating] | None = None,
     covcache: _CovarianceCache | None = None,
+    col_norms_sq: NDArray[np.floating] | None = None,
     stepno: int = 20,
     nu: float = 0.1,
     csf: float = 0.9,
@@ -177,6 +194,7 @@ def allboost(
     mandatory_ridge: float | NDArray[np.floating] = 0.0,
     beta_init: NDArray[np.floating] | None = None,
     covcache: _CovarianceCache | None = None,
+    col_norms_sq: NDArray[np.floating] | None = None,
     stepno: int = 20,
     nu: float = 0.1,
     csf: float = 0.9,
@@ -195,6 +213,7 @@ def allboost(
     mandatory_ridge: float | NDArray[np.floating] = 0.0,
     beta_init: NDArray[np.floating] | None = None,
     covcache: _CovarianceCache | None = None,
+    col_norms_sq: NDArray[np.floating] | None = None,
     stepno: int = 20,
     nu: float = 0.1,
     csf: float = 0.9,
@@ -213,6 +232,7 @@ def allboost(
     mandatory_ridge: float | NDArray[np.floating] = 0.0,
     beta_init: NDArray[np.floating] | None = None,
     covcache: _CovarianceCache | None = None,
+    col_norms_sq: NDArray[np.floating] | None = None,
     stepno: int = 20,
     nu: float = 0.1,
     csf: float = 0.9,
@@ -230,6 +250,7 @@ def allboost(
     mandatory_ridge: float | NDArray[np.floating] = 0.0,
     beta_init: NDArray[np.floating] | None = None,
     covcache: _CovarianceCache | None = None,
+    col_norms_sq: NDArray[np.floating] | None = None,
     stepno: int = 20,
     nu: float = 0.1,
     csf: float = 0.9,
@@ -291,6 +312,14 @@ def allboost(
         full-cache fast path. A dict maps feature indices to covariance columns
         and grows only when a feature is selected. If None, an empty column
         cache is created. Reuse the returned cache with the same sourcemat only.
+    col_norms_sq : ndarray of shape (n_features,), optional
+        Pre-computed squared column norms, as returned by :func:`column_norms_sq`.
+        Computed internally when None. Supplying it skips an O(n*p) pass and a
+        full ``(n_samples, n_features)`` temporary per call, which matters when
+        ``allboost`` is called repeatedly against an unchanging ``sourcemat`` --
+        once per training iteration, in :meth:`structboost.BAE.fit`. It carries
+        the same staleness contract as ``covcache``: reuse it with the same
+        ``sourcemat`` only.
     stepno : int, default=20
         Number of boosting iterations per target.
     nu : float, default=0.1
@@ -377,6 +406,20 @@ def allboost(
             f"sourcemat and targetmat must have same n_samples, got {n} and {targetmat.shape[0]}"
         )
 
+    # Match the target's dtype to the predictors'. Left alone, a float32
+    # `sourcemat` against a float64 `targetmat` makes numpy promote *sourcemat*
+    # inside every predictor-target product -- materializing a full float64 copy
+    # of the design matrix, measured 20-25x slower than the matched-dtype path.
+    # Casting the (n_samples, n_targets) target instead is the cheap direction,
+    # and it fixes the precision of the fit at the predictors', which is where
+    # the O(n) accumulations that actually limit accuracy happen.
+    if (
+        np.issubdtype(sourcemat.dtype, np.floating)
+        and np.issubdtype(targetmat.dtype, np.floating)
+        and sourcemat.dtype != targetmat.dtype
+    ):
+        targetmat = targetmat.astype(sourcemat.dtype, copy=False)
+
     mandatory_per_target = _validate_mandatory_features(mandatory_features, p, k)
     ridge = np.asarray(mandatory_ridge, dtype=np.float64)
     if ridge.ndim == 0:
@@ -396,8 +439,16 @@ def allboost(
         if not np.isfinite(beta_init).all():
             raise ValueError("beta_init must contain only finite values")
 
-    # Precompute column squared norms (used for penalty scaling and residual updates)
-    col_norms_sq = (sourcemat**2).sum(axis=0)
+    # Column squared norms (used for penalty scaling and residual updates). A
+    # caller looping over the same `sourcemat` can hoist this out with
+    # `column_norms_sq` and hand it back; it is otherwise an O(n*p) pass plus a
+    # full (n_samples, n_features) temporary on every single call.
+    if col_norms_sq is None:
+        col_norms_sq = column_norms_sq(sourcemat)
+    else:
+        col_norms_sq = np.asarray(col_norms_sq)
+        if col_norms_sq.shape != (p,):
+            raise ValueError(f"col_norms_sq must have shape ({p},), got {col_norms_sq.shape}")
 
     # Check for zero-variance columns
     if (col_norms_sq == 0).any():
@@ -441,15 +492,38 @@ def allboost(
             raise ValueError(f"covcache must have shape ({p}, {p}), got {covcache.shape}")
         _covcache = covcache
 
+        # A column needs its NaN scan only once per call: after the first look it
+        # is either clean or has just been filled in below, and neither state can
+        # revert -- a later fill of some other column writes values, never NaNs.
+        # Re-scanning on every access spends an O(p) pass per boosting step for
+        # nothing, and the mandatory block alone touches its columns `stepno`
+        # times per target.
+        _verified = np.zeros(p, dtype=bool)
+
         def get_covariance_column(j: int) -> NDArray[np.floating]:
             column = _covcache[:, j]
-            nan_mask = np.isnan(column)
-            if nan_mask.any():
-                computed = sourcemat[:, nan_mask].T @ sourcemat[:, j]
-                column[nan_mask] = computed
-                _covcache[j, nan_mask] = computed
+            if not _verified[j]:
+                nan_mask = np.isnan(column)
+                if nan_mask.any():
+                    computed = sourcemat[:, nan_mask].T @ sourcemat[:, j]
+                    column[nan_mask] = computed
+                    _covcache[j, nan_mask] = computed
+                _verified[j] = True
             return column
 
+    # Starting residual correlations for *every* target at once. One
+    # (n_features, n_targets) matrix product instead of one matrix-vector product
+    # per target: same quantity, but a compute-bound gemm rather than k
+    # memory-bound gemv passes over sourcemat, measured ~3.8x faster. With
+    # `beta_init` the residual is taken at the offset model rather than at zero --
+    # otherwise the first selection step would re-fit signal the offset already
+    # explains -- and that too batches into a single product.
+    if beta_init is None:
+        residuals = targetmat
+    else:
+        residuals = targetmat - sourcemat @ beta_init.T
+    initial_nom = (sourcemat.T @ residuals) / col_norms_sq[:, None]
+
     # Initialize shared state (used if independent=False)
     if not independent:
         nuvec = np.full(p, nu, dtype=np.float64)
@@ -461,30 +535,25 @@ def allboost(
             nuvec = np.full(p, nu, dtype=np.float64)
             penvec = col_norms_sq * (1.0 / nu - 1.0)
 
-        curtarget = targetmat[:, t_idx]
-        if beta_init is None:
-            actualnom, _ = _calc_unibeta(sourcemat, curtarget, col_norms_sq)
-            beta = np.zeros(p, dtype=np.float64)
-        else:
-            # Boosting from the offset model F_0 = sourcemat @ beta. `actualnom`
-            # must describe the residual *at* beta, not at zero, or the first
-            # selection step would re-fit signal the offset already explains.
-            # Forming the residual directly costs one O(n*p) matvec; deriving it
-            # from the covariance cache instead would cost one column fetch per
-            # non-zero initial coefficient.
-            beta = beta_init[t_idx].copy()
-            actualnom, _ = _calc_unibeta(sourcemat, curtarget - sourcemat @ beta, col_norms_sq)
+        # `.copy()` is required: actualnom is updated in place below.
+        actualnom = initial_nom[:, t_idx].copy()
+        beta = np.zeros(p, dtype=np.float64) if beta_init is None else beta_init[t_idx].copy()
         mand_idx = mandatory_per_target[t_idx]
+        # Built once per target: nothing in it depends on the boosting step.
+        mand_block = (
+            _MandatoryBlock(mand_idx, col_norms_sq, get_covariance_column, ridge)
+            if mand_idx.size > 0
+            else None
+        )
 
         for step in range(stepno):
-            if mand_idx.size > 0:
+            if mand_block is not None:
                 actualnom, beta = _mandatory_prestep(
                     mand_idx,
                     actualnom,
                     beta,
                     col_norms_sq,
-                    get_covariance_column,
-                    ridge,
+                    mand_block,
                     t_idx,
                 )
 

{structboost-0.1.2 → structboost-0.2.0}/src/structboost/_model.py

@@ -15,7 +15,7 @@ from torch import nn
 from torch.utils.data import DataLoader, TensorDataset
 from tqdm import tqdm
 
-from ._boosting import allboost
+from ._boosting import allboost, column_norms_sq
 from ._decoder import BAEDecoder
 from ._encoder import BAEEncoder, SplitSoftmax
 from ._types import BAEConfig, TrainingReport
@@ -461,6 +461,8 @@ class BAE(nn.Module):
         self._prior_weights: np.ndarray | None = None
         self._prior_info: dict[str, object] = {}
         self._latent_scaling: dict[str, np.ndarray] | None = None
+        #: Whether the last fit built a full covariance matrix; recorded in uns.
+        self._precomputed_covcache: bool = False
 
         # Move to device
         self.to(self.config.device)
@@ -1935,13 +1937,33 @@ class BAE(nn.Module):
         if n_nuisance:
             mandatory_ridge[self.n_genes :] = nuisance_ridge
 
-        if self.config.boosting_precompute_covcache:
+        # A frozen transfer with no added dimensions never calls allboost at all
+        # (there is nothing left to select), so building a covariance matrix for
+        # it would be pure waste -- 8*p^2 bytes and an O(n*p^2) product for a
+        # cache no one reads.
+        boosts_anything = not (
+            is_transfer
+            and self.config.prior_mode == "frozen"
+            and self._prior_weights.shape[1] >= self.config.latent_dim
+        )
+        from ._utils import resolve_precompute_covcache
+
+        precompute_covcache = boosts_anything and resolve_precompute_covcache(
+            self.config.boosting_precompute_covcache, sourcemat_aug.shape[1]
+        )
+        self._precomputed_covcache = precompute_covcache
+        if precompute_covcache:
             from ._utils import compute_covariance_cache
 
             covcache = compute_covariance_cache(sourcemat_aug)
         else:
             covcache = None  # Lazy computation during allboost
 
+        # `sourcemat_aug` is fixed for the whole fit, so its column norms are too.
+        # allboost recomputes them on every call otherwise -- an O(n*p) pass and a
+        # full-size temporary, once per training iteration.
+        boosting_col_norms_sq = column_norms_sq(sourcemat_aug)
+
         # Optimizer for decoder only
         decoder_optimizer = torch.optim.AdamW(
             self.decoder.parameters(),
@@ -2065,6 +2087,7 @@ class BAE(nn.Module):
                     sourcemat_aug,
                     fit_targets,
                     covcache=covcache,
+                    col_norms_sq=boosting_col_norms_sq,
                     stepno=self.config.boosting_stepno,
                     nu=self.config.boosting_nu,
                     csf=self.config.boosting_csf,
@@ -2079,6 +2102,7 @@ class BAE(nn.Module):
                     sourcemat_aug,
                     fit_targets,
                     covcache=covcache,
+                    col_norms_sq=boosting_col_norms_sq,
                     stepno=self.config.boosting_stepno,
                     nu=self.config.boosting_nu,
                     csf=self.config.boosting_csf,
@@ -2373,7 +2397,12 @@ class BAE(nn.Module):
         identical to the training loop; ``tests/test_stability.py`` pins that
         equivalence so the two cannot silently diverge.
         """
-        from ._utils import resolve_mandatory_genes, transform_obs_covariates
+        from ._utils import (
+            compute_covariance_cache,
+            resolve_mandatory_genes,
+            resolve_precompute_covcache,
+            transform_obs_covariates,
+        )
 
         if n_iterations < 1:
             raise ValueError(f"n_iterations must be >= 1, got {n_iterations}")
@@ -2398,11 +2427,15 @@ class BAE(nn.Module):
             else None
         )
 
-        sourcemat_aug = X_np.astype(np.float64)
+        # float32, matching `fit`. This path used to promote to float64 on top of
+        # the float32 copy above -- three copies of the expression matrix resident
+        # at once -- buying a precision difference measured at about one gene in
+        # 380, far inside the run-to-run support variation this method documents.
+        sourcemat_aug = X_np
         n_nuisance = 0
         if self._regresses_encoder:
             D_nuisance = transform_obs_covariates(adata, self._batch_encoding)
-            sourcemat_aug = np.hstack([sourcemat_aug, np.asarray(D_nuisance, dtype=np.float64)])
+            sourcemat_aug = np.hstack([sourcemat_aug, np.asarray(D_nuisance, dtype=np.float32)])
             n_nuisance = self._batch_encoding.n_columns
 
         resolved_mandatory = resolve_mandatory_genes(self._mandatory_genes, adata)
@@ -2410,6 +2443,17 @@ class BAE(nn.Module):
         mandatory_ridge = np.zeros(sourcemat_aug.shape[1], dtype=np.float64)
         if n_nuisance:
             mandatory_ridge[self.n_genes :] = self.config.nuisance_ridge
+        # Fixed across every iteration recorded here, exactly as in `fit`.
+        boosting_col_norms_sq = column_norms_sq(sourcemat_aug)
+        # Honour the same covariance-cache setting `fit` resolved. Without this,
+        # the method documented as mirroring the fit loop would run a different
+        # cache strategy from the fit it is analysing.
+        if resolve_precompute_covcache(
+            self.config.boosting_precompute_covcache, sourcemat_aug.shape[1]
+        ):
+            covcache_initial = compute_covariance_cache(sourcemat_aug)
+        else:
+            covcache_initial = None
 
         # Snapshot so the fitted model is unchanged when this returns.
         saved_encoder = self.encoder.linear.weight.detach().clone()
@@ -2431,7 +2475,7 @@ class BAE(nn.Module):
 
         reference_unit = _unit_rows(reference)
 
-        covcache = None
+        covcache = covcache_initial
         latent_dim = reference.shape[0]
         prior_dims = self._prior_weights.shape[1] if self._prior_weights is not None else 0
         counts = np.zeros((self.n_genes, latent_dim), dtype=np.float64)
@@ -2476,6 +2520,7 @@ class BAE(nn.Module):
                         sourcemat_aug,
                         fit_targets,
                         covcache=covcache,
+                        col_norms_sq=boosting_col_norms_sq,
                         stepno=self.config.boosting_stepno,
                         nu=self.config.boosting_nu,
                         csf=self.config.boosting_csf,
@@ -2772,11 +2817,12 @@ class BAE(nn.Module):
             sample_weights=weights_t,
         )
 
-        sourcemat = X_np.astype(np.float64)
+        # float32, matching `fit`; see _iteration_support_frequency.
+        sourcemat = X_np
         n_nuisance = 0
         if self._regresses_encoder:
             D_nuisance = transform_obs_covariates(adata, self._batch_encoding)
-            sourcemat = np.hstack([sourcemat, np.asarray(D_nuisance, dtype=np.float64)])
+            sourcemat = np.hstack([sourcemat, np.asarray(D_nuisance, dtype=np.float32)])
             n_nuisance = self._batch_encoding.n_columns
 
         resolved_mandatory = resolve_mandatory_genes(self._mandatory_genes, adata)
@@ -3351,6 +3397,9 @@ class BAE(nn.Module):
         if hasattr(self, "_mandatory_genes") and self._mandatory_genes is not None:
             uns_dict["mandatory_genes"] = _mandatory_genes_for_uns(self._mandatory_genes)
         uns_dict["batch_integration_mode"] = self._batch_integration_mode
+        # The *resolved* decision, not the setting: "auto" is the default, so
+        # without this a run does not record which strategy it actually used.
+        uns_dict["boosting_precompute_covcache"] = bool(self._precomputed_covcache)
         if self._batch_encoding is not None:
             uns_dict["batch_key"] = self._batch_encoding.obs_columns
             uns_dict["batch_columns"] = self._batch_encoding.encoded_columns

{structboost-0.1.2 → structboost-0.2.0}/src/structboost/_stability.py

@@ -303,8 +303,12 @@ def stability_selection(
     -------
     StabilitySelectionResult
     """
-    sourcemat = np.asarray(sourcemat, dtype=np.float64)
-    targetmat = np.asarray(targetmat, dtype=np.float64)
+    # Dtype is the caller's; allboost aligns the target to the predictors.
+    # Forcing float64 here used to double the memory of every BAE-driven call
+    # (the caller already holds a float32 copy) for a precision difference
+    # measured at about one gene in 380.
+    sourcemat = np.asarray(sourcemat)
+    targetmat = np.asarray(targetmat)
     n = sourcemat.shape[0]
     if targetmat.shape[0] != n:
         raise ValueError(
@@ -351,6 +355,17 @@ def stability_selection(
         idx = rng.choice(n, size=sub_n, replace=False)
         # A fresh covcache per subsample is mandatory: the Gram matrix depends on
         # the rows, so the full-data cache would silently produce wrong updates.
+        #
+        # Deliberately lazy, unlike `BAE.fit`, which precomputes the whole Gram by
+        # default. Building it per subsample was measured and rejected: on real
+        # data at n=15,000 it runs 3.07x faster at p=2,000 and 2.69x at p=3,000,
+        # but 0.73-0.85x *slower* from p=6,000 upwards. The crossover is governed
+        # by the number of distinct columns a subsample actually selects, which
+        # stays roughly flat (~110-240) as p grows, so the full p x p product
+        # stops paying for itself. A memory guard cannot separate those cases --
+        # the 800 MB Gram at p=10,000 fits comfortably and still loses -- and any
+        # p threshold would be calibrated on one dataset's support size. Left
+        # lazy, which is the safe direction at every p.
         betamat = allboost(
             sourcemat[idx],
             targetmat[idx],

{structboost-0.1.2 → structboost-0.2.0}/src/structboost/_types.py

@@ -106,15 +106,30 @@ class BAEConfig:
         few hundred iterations, since the encoder support random-walks and two
         runs end no more similar than two unrelated ones.
     boosting_precompute_covcache
-        If True, compute the full p×p covariance matrix before training, which
-        costs 8·p² bytes (3.2 GB at p=20,000).
-        If False (default), `allboost` keeps a dict-backed column cache: a
-        covariance column is computed the first time its feature is selected and
-        reused across targets and training iterations. Memory then scales with
-        the number of *distinct selected* features (8·p bytes per column), not
-        with p², which is a large saving because boosting selects far fewer
-        features than are available. Precompute only when p is small enough that
-        the full matrix is comfortable and many features will be selected anyway.
+        Whether to compute the full p×p covariance matrix before training.
+        ``"auto"`` (default) does so whenever the 8·p² byte matrix fits a
+        conservative share of system memory; ``True`` and ``False`` are honoured
+        exactly. The resolved decision is recorded in
+        ``adata.uns["bae"]["boosting_precompute_covcache"]``.
+
+        This is a *speed* setting first and a memory setting second, which is not
+        obvious. The alternative is a dict-backed column cache: a covariance
+        column is computed the first time its feature is selected and reused
+        across targets and iterations, so memory scales with the number of
+        *distinct selected* features (8·p bytes per column) rather than with p².
+        That sounds strictly cheaper, and in memory it is — but building all p
+        columns at once is a single compute-bound matrix product running near
+        hardware peak, while fetching them one at a time is a sequence of
+        memory-bound matrix-vector products. Measured on real data, precomputing
+        wins from roughly ``p/59`` distinct selected features onwards, and a fit
+        passes that within its first iteration, where up to
+        ``boosting_stepno × latent_dim`` distinct features can enter. End-to-end
+        it measured 1.7–2.3× faster at p=3,000–10,000.
+
+        The cost is memory, and it is real: 8·p² is 32 MB at p=2,000, 800 MB at
+        p=10,000 and 3.2 GB at p=20,000, transiently doubled while the matrix is
+        built. That is what ``"auto"`` guards against; set ``False`` explicitly on
+        a memory-constrained machine.
     disentanglement
         Latent-dimension disentanglement method. ``"none"`` (default) applies no
         constraint. ``"correlation"`` adds a soft, differentiable squared-
@@ -212,7 +227,7 @@ class BAEConfig:
     boosting_nu: float = 0.1
     boosting_csf: float = 0.9
     boosting_independent: bool = True
-    boosting_precompute_covcache: bool = False
+    boosting_precompute_covcache: bool | Literal["auto"] = "auto"
     nuisance_ridge: float = 0.0
     prior_mode: Literal["frozen", "anchored"] = "frozen"
     disentanglement: Literal["none", "correlation", "leave_one_out"] = "none"
@@ -245,6 +260,11 @@ class BAEConfig:
             raise ValueError("boosting_stepno must be >= 1")
         if not np.isfinite(self.nuisance_ridge) or self.nuisance_ridge < 0:
             raise ValueError("nuisance_ridge must be finite and >= 0")
+        if self.boosting_precompute_covcache not in (True, False, "auto"):
+            raise ValueError(
+                "boosting_precompute_covcache must be True, False or 'auto', got "
+                f"{self.boosting_precompute_covcache!r}"
+            )
         if self.prior_mode not in {"frozen", "anchored"}:
             raise ValueError("prior_mode must be 'frozen' or 'anchored'")
         if not 0.0 < self.boosting_nu <= 1.0:

{structboost-0.1.2 → structboost-0.2.0}/src/structboost/_utils.py

@@ -64,7 +64,68 @@ def compute_covariance_cache(
         np.dot(sourcemat.T, sourcemat, out=out)
         return out
 
-    return np.dot(sourcemat.T, sourcemat).astype(np.float64, copy=False)
+    # Fortran order, so that ``covcache[:, j]`` -- the only way allboost ever
+    # reads this matrix -- is a contiguous vector rather than a stride of 8*p
+    # bytes. Reading a column of the C-ordered equivalent touches one cache line
+    # per element and measured 4-9x slower inside the boosting loop.
+    #
+    # The values are identical either way; only the layout differs. numpy will
+    # not write a gemm result straight into an F-ordered ``out``, so this costs
+    # one transient copy of the p x p matrix at build time -- negligible against
+    # the O(n*p^2) product itself, but it does mean the peak allocation here is
+    # briefly twice the returned size.
+    return np.asfortranarray(np.dot(sourcemat.T, sourcemat), dtype=np.float64)
+
+
+#: Fraction of total system memory the automatic covariance-cache decision is
+#: willing to spend on the p x p Gram matrix. Deliberately conservative: the
+#: matrix is transiently doubled while it is built (see
+#: :func:`compute_covariance_cache`), and a fit needs room for the expression
+#: matrix and the decoder besides.
+_PRECOMPUTE_MEMORY_FRACTION = 0.25
+
+#: Used when the platform does not expose its physical memory (non-POSIX).
+_PRECOMPUTE_FALLBACK_BUDGET = 2 * 1024**3
+
+
+def _total_memory_bytes() -> int | None:
+    """Physical memory, or None where the platform will not say."""
+    try:
+        import os
+
+        return int(os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES"))
+    except (ValueError, AttributeError, OSError):  # pragma: no cover - platform dependent
+        return None
+
+
+def resolve_precompute_covcache(setting: bool | str, n_features: int) -> bool:
+    """Decide whether to build the full covariance matrix up front.
+
+    ``True``/``False`` are honoured exactly; ``"auto"`` precomputes whenever the
+    ``8 * n_features**2`` byte matrix fits the memory budget above.
+
+    Precomputing is not merely a way to avoid recomputing columns. Building all
+    ``p`` columns at once is a single compute-bound matrix product running near
+    hardware peak, whereas fetching them one at a time is a sequence of
+    memory-bound matrix-vector products; measured on real data the former wins
+    from roughly ``p/59`` distinct selected features onwards, and a BAE fit
+    passes that in its first iteration (``boosting_stepno * latent_dim``
+    candidates). The decision here is therefore about memory, not about how many
+    columns will be needed.
+    """
+    if setting is True or setting is False:
+        return bool(setting)
+    if setting != "auto":
+        raise ValueError(
+            f"boosting_precompute_covcache must be True, False or 'auto', got {setting!r}"
+        )
+    total = _total_memory_bytes()
+    budget = (
+        int(total * _PRECOMPUTE_MEMORY_FRACTION)
+        if total is not None
+        else _PRECOMPUTE_FALLBACK_BUDGET
+    )
+    return 8 * int(n_features) ** 2 <= budget
 
 
 def disentangle_boosting_targets(

structboost-0.2.0/tests/test_covcache_precompute.py

@@ -0,0 +1,250 @@
+"""Contracts for the covariance-cache strategy and the boosting dtype rules.
+
+These pin the *mechanism* behind the speed of the boosting loop rather than a
+wall-clock number: how often an invariant quantity is recomputed, whether the
+design matrix is silently promoted, and which cache strategy a fit resolved to.
+Timing assertions would be flaky in CI; call counts and dtypes are exact.
+"""
+
+import numpy as np
+import pytest
+
+from structboost import BAEConfig, allboost, compute_covariance_cache
+from structboost._boosting import column_norms_sq
+from structboost._utils import resolve_precompute_covcache
+
+
+def _require_bae():
+    pytest.importorskip("torch")
+    pytest.importorskip("anndata")
+
+
+@pytest.fixture
+def f32_data():
+    """float32 predictors and targets, the dtypes ``BAE.fit`` actually uses."""
+    rng = np.random.default_rng(7)
+    x = rng.standard_normal((300, 60)).astype(np.float32)
+    x = (x - x.mean(axis=0)) / x.std(axis=0)
+    y = rng.standard_normal((300, 4)).astype(np.float32)
+    return x, y
+
+
+class TestCovarianceCacheEquivalence:
+    def test_lazy_and_precomputed_agree_in_float32(self, f32_data):
+        """The float64 fixture elsewhere hides this: at float32 the two cache
+        strategies differ in the last bits, so the contract is that they select
+        the same genes, not that they produce identical coefficients."""
+        x, y = f32_data
+        lazy = allboost(x, y, stepno=15)
+        pre = allboost(x, y, covcache=compute_covariance_cache(x), stepno=15)
+
+        np.testing.assert_array_equal(np.abs(lazy) > 0, np.abs(pre) > 0)
+        np.testing.assert_allclose(lazy, pre, rtol=1e-5, atol=1e-7)
+
+    def test_precomputed_cache_is_column_contiguous(self):
+        """allboost only ever reads ``covcache[:, j]``; a C-ordered Gram makes
+        that a strided read touching one cache line per element."""
+        rng = np.random.default_rng(0)
+        cache = compute_covariance_cache(rng.standard_normal((80, 25)))
+        assert cache.flags.f_contiguous
+        assert cache[:, 3].flags.contiguous
+
+
+class TestColumnNormsHoist:
+    def test_hoisted_norms_reproduce_the_internal_value(self, f32_data):
+        """Passing ``col_norms_sq`` must be indistinguishable from letting
+        allboost compute it -- that is what makes hoisting it out of a training
+        loop safe."""
+        x, y = f32_data
+        internal = allboost(x, y, stepno=12)
+        hoisted = allboost(x, y, stepno=12, col_norms_sq=column_norms_sq(x))
+        np.testing.assert_array_equal(internal, hoisted)
+
+    def test_wrong_shape_rejected(self, f32_data):
+        x, y = f32_data
+        with pytest.raises(ValueError, match="col_norms_sq must have shape"):
+            allboost(x, y, stepno=5, col_norms_sq=np.ones(3))
+
+    def test_computed_once_per_fit_not_once_per_iteration(self):
+        _require_bae()
+        import anndata as ad
+
+        import structboost._model as model_module
+        from structboost import BAE
+
+        rng = np.random.default_rng(0)
+        adata = ad.AnnData(rng.standard_normal((200, 40), dtype=np.float32))
+        calls = []
+        original = model_module.column_norms_sq
+        model_module.column_norms_sq = lambda m: (calls.append(1), original(m))[1]
+        try:
+            BAE(40, BAEConfig(latent_dim=2, seed=0, max_iterations=6)).fit(
+                adata, verbose=False, enable_early_stopping=False
+            )
+        finally:
+            model_module.column_norms_sq = original
+        assert sum(calls) == 1, f"recomputed {sum(calls)}x across 6 iterations"
+
+
+class TestMandatoryBlockHoist:
+    def test_block_built_once_per_target(self):
+        """Nothing in the mandatory block depends on the boosting step, so it
+        must be built ``n_targets`` times, not ``n_targets * stepno``."""
+        import structboost._boosting as boosting
+
+        rng = np.random.default_rng(1)
+        x = rng.standard_normal((200, 30))
+        y = rng.standard_normal((200, 3))
+        built = []
+        original = boosting._MandatoryBlock
+
+        class Counting(original):
+            def __init__(self, *args, **kwargs):
+                built.append(1)
+                super().__init__(*args, **kwargs)
+
+        boosting._MandatoryBlock = Counting
+        try:
+            allboost(x, y, stepno=9, mandatory_features=np.array([0, 4], dtype=np.intp))
+        finally:
+            boosting._MandatoryBlock = original
+        assert sum(built) == 3, f"built {sum(built)}x for 3 targets x 9 steps"
+
+
+class TestTargetDtypeAlignment:
+    def test_float64_target_does_not_promote_the_design_matrix(self, f32_data):
+        """A float64 target against float32 predictors used to make numpy promote
+        *sourcemat*, materializing a full float64 copy per latent dimension. The
+        target is aligned to the predictors instead, so both give one answer."""
+        x, y = f32_data
+        from_f32 = allboost(x, y, stepno=12)
+        from_f64 = allboost(x, y.astype(np.float64), stepno=12)
+        np.testing.assert_array_equal(from_f32, from_f64)
+
+    def test_integer_targets_still_accepted(self, f32_data):
+        x, _ = f32_data
+        y = np.arange(x.shape[0] * 2, dtype=np.int64).reshape(-1, 2) % 5
+        assert np.isfinite(allboost(x, y, stepno=4)).all()
+
+
+class TestPrecomputeResolver:
+    def test_auto_precomputes_when_the_matrix_is_small(self):
+        assert resolve_precompute_covcache("auto", 500) is True
+
+    def test_auto_declines_when_the_matrix_cannot_fit(self):
+        # 8 * p^2 is well beyond any machine's memory at this width.
+        assert resolve_precompute_covcache("auto", 400_000) is False
+
+    @pytest.mark.parametrize("setting", [True, False])
+    def test_explicit_setting_always_wins(self, setting):
+        assert resolve_precompute_covcache(setting, 400_000) is setting
+        assert resolve_precompute_covcache(setting, 10) is setting
+
+    def test_invalid_setting_rejected(self):
+        with pytest.raises(ValueError, match="must be True, False or 'auto'"):
+            resolve_precompute_covcache("sometimes", 10)
+
+    def test_config_validates_the_field(self):
+        with pytest.raises(ValueError, match="must be True, False or 'auto'"):
+            BAEConfig(boosting_precompute_covcache="yes")
+
+    def test_default_is_auto(self):
+        assert BAEConfig().boosting_precompute_covcache == "auto"
+
+
+class TestFitRecordsResolvedStrategy:
+    @pytest.mark.parametrize("setting,expected", [("auto", True), (True, True), (False, False)])
+    def test_uns_records_the_resolved_decision(self, setting, expected):
+        """ "auto" is the default, so without recording it a run does not say
+        which strategy it actually used."""
+        _require_bae()
+        import anndata as ad
+
+        from structboost import BAE
+
+        rng = np.random.default_rng(0)
+        adata = ad.AnnData(rng.standard_normal((150, 30), dtype=np.float32))
+        BAE(
+            30,
+            BAEConfig(latent_dim=2, seed=0, max_iterations=3, boosting_precompute_covcache=setting),
+        ).fit(adata, verbose=False, enable_early_stopping=False)
+        assert adata.uns["bae"]["boosting_precompute_covcache"] is expected
+
+
+class TestTransferSkipsUnusedCache:
+    def test_frozen_transfer_without_new_dims_builds_no_gram(self):
+        """A frozen transfer with no added dimensions never calls allboost, so
+        building an 8*p^2 covariance matrix for it is pure waste."""
+        _require_bae()
+        import anndata as ad
+
+        import structboost._utils as utils
+        from structboost import BAE
+
+        rng = np.random.default_rng(0)
+        adata = ad.AnnData(rng.standard_normal((150, 30), dtype=np.float32))
+        adata.var_names = [f"g{i}" for i in range(30)]
+        cfg = dict(latent_dim=2, seed=0, max_iterations=3)
+        reference = BAE(30, BAEConfig(**cfg)).fit(
+            adata.copy(), verbose=False, enable_early_stopping=False
+        )
+
+        built = []
+        original = utils.compute_covariance_cache
+        utils.compute_covariance_cache = lambda *a, **k: (built.append(1), original(*a, **k))[1]
+        try:
+            target = adata.copy()
+            BAE.from_reference(
+                reference,
+                target,
+                n_additional_dims=0,
+                prior_mode="frozen",
+                config=BAEConfig(**cfg),
+            ).fit(target, verbose=False, enable_early_stopping=False)
+            assert sum(built) == 0
+
+            target2 = adata.copy()
+            BAE.from_reference(
+                reference,
+                target2,
+                n_additional_dims=2,
+                prior_mode="frozen",
+                config=BAEConfig(**cfg),
+            ).fit(target2, verbose=False, enable_early_stopping=False)
+            assert sum(built) >= 1
+        finally:
+            utils.compute_covariance_cache = original
+
+
+class TestStabilityPathsMatchFit:
+    def test_iteration_mode_runs_the_same_dtype_as_fit(self):
+        """The three entry points to the same boosting problem used to run at two
+        different precisions, with the stability paths holding an extra float64
+        copy of the whole expression matrix."""
+        _require_bae()
+        import anndata as ad
+
+        import structboost._model as model_module
+        from structboost import BAE
+
+        rng = np.random.default_rng(0)
+        adata = ad.AnnData(rng.standard_normal((200, 30), dtype=np.float32))
+        model = BAE(30, BAEConfig(latent_dim=2, seed=0, max_iterations=4)).fit(
+            adata, verbose=False, enable_early_stopping=False
+        )
+
+        seen = {}
+        original = model_module.allboost
+
+        def probe(sourcemat, targetmat, **kwargs):
+            seen.setdefault("source", sourcemat.dtype)
+            seen.setdefault("target", targetmat.dtype)
+            return original(sourcemat, targetmat, **kwargs)
+
+        model_module.allboost = probe
+        try:
+            model.stability_selection(adata, mode="iteration", n_runs=2, seed=0, verbose=False)
+        finally:
+            model_module.allboost = original
+        assert seen["source"] == np.float32
+        assert seen["target"] == np.float32

structboost-0.1.2/CHANGELOG.md

@@ -1,66 +0,0 @@
-## Changelog
-
-Releases follow [semantic versioning](https://semver.org). While the project is
-pre-1.0, a minor bump may break API.
-
-### [0.1.2] - 2026-08-03
-
-Project metadata gains `Documentation` and `Changelog` links. PyPI renders
-`project.urls` as the sidebar next to the project description, and it carried
-only the repository and the issue tracker — so the documentation site, where
-every substantive explanation lives, was reachable from the README body but not
-from the navigation beside it. Both targets are verified live.
-
-As with 0.1.1, nothing in the package changed: `project.urls` reaches users only
-through an upload, so correcting it in the repository has no effect until a
-release carries it.
-
-### [0.1.1] - 2026-08-03
-
-A metadata release. No code in `structboost` changed; every difference is in
-what the package says about itself.
-
-The PyPI page is the reason for it. A project's long description is baked into
-the uploaded artifacts and is immutable per release, so 0.1.0 shipped with a
-README announcing "Not on PyPI yet" and directing readers to a pinned TestPyPI
-install. Correcting the file in git does not touch the published page — only a
-new release does. A `0.1.0.post1` would have expressed "packaging only" more
-precisely, but post-releases are handled inconsistently by downstream tooling
-and the versioning policy here is plain `MAJOR.MINOR.PATCH`.
-
-Python 3.13 is tested and advertised. `requires-python = ">=3.10"` never had an
-upper bound, so pip already installed on 3.13 while the CI matrix stopped at
-3.12 — support permitted but never exercised. The matrix now covers it, and the
-classifier list says what the requirement already allowed. 3.14 is left out
-until the `[bae]` extra's wheels are dependably available there.
-
-`CITATION.cff` gains `version` and `date-released`, which a citation file for a
-released version cannot do without, plus a `url` for the documentation site.
-
-### [0.1.0] - 2026-07-31
-
-First public release.
-
-Batch integration is one argument. `BAE.fit(batch_key=...)` names the covariate,
-following scVI's spelling, and `batch_integration_mode` chooses between
-`"decoder"`, `"encoder"` and `"both"`, defaulting to `"both"`. No `batch_key`
-means no integration, and naming a mode without one raises rather than quietly
-integrating nothing.
-
-`"encoder"` names the half of the model the mechanism protects, not a tensor the
-covariate is fed to: it enters the boosting design as a mandatory regressor so
-gene selection is not confounded by it. `transform` remains gene-only and needs
-no covariate labels under any mode.
-
-The ridge that stabilizes near-collinear covariates is `BAEConfig.nuisance_ridge`.
-It is a numerical knob rather than a modelling one, so it sits with the other
-algorithm settings.
-
-The `test` extra pulls the runtime dependencies. The sdist carries `tests/` and
-`conftest.py` so that downstream packagers can run the suite at build time, and
-with pytest alone that did not work: 360 of the 411 test functions sit behind an
-`importorskip` for torch or anndata, so `pip install .[test] && pytest` ran ~51
-tests, skipped the rest and reported success. Installing `[test]` now brings in
-`[bae]`, so a green build means the suite actually ran. Documenting the
-requirement in `CONTRIBUTING.md` instead was rejected, because the reader who
-needs it is an automated build script rather than a person.