structboost 0.1.2__tar.gz → 0.3.0__tar.gz

structboost-0.3.0/CHANGELOG.md

@@ -0,0 +1,206 @@
+## Changelog
+
+Releases follow [semantic versioning](https://semver.org). While the project is
+pre-1.0, a minor bump may break API.
+
+### [0.3.0] - 2026-08-11
+
+**Breaking.** Five settings are gone and `BAE.stability_selection` has one mode
+instead of two. Every removed option was off by default, so a fit that took the
+defaults is unaffected: the encoder matrix is bitwise identical across a plain
+fit, a batch-integrated fit, and both disentanglement methods. What changes is the
+surface you have to reason about.
+
+`boosting_nu` stays at `0.1`. Raising it to `0.3` was measured and deferred: at
+the default `stepno=50` it matches `0.1`'s marker recovery three to four times
+faster and wins outright on low-signal data, but then degrades if training
+continues, and the training-MSE stopping rule cannot see it happening. The guide
+records the numbers; the two changes belong together and will land together.
+
+**Checkpoints written by 0.2.0 no longer load.** `restore_payload` splats the
+stored config into `BAEConfig`, so a dropped field is an unexpected keyword
+argument rather than a missing one. The format is bumped to 5 and the loader
+refuses 4 by name. No migration is written: the method is under active
+development and a checkpoint is cheap to regenerate, whereas a compatibility
+shim for options that no longer exist is not.
+
+Removed from `BAEConfig`:
+
+- `decoder_dropout_rate` and `decoder_use_batch_norm`. Batch norm was already
+  documented as harmful (marker-recovery F1 0.59-0.73) because the boosting
+  target is computed with the decoder in eval mode and the update applied in
+  train mode. Dropout has exactly the same inconsistency and it was never written
+  down: the target comes from the full network, the update from a thinned one.
+  With both gone the decoder is a deterministic per-cell function, which is the
+  property `_compute_boosting_targets` has always relied on.
+- `disentanglement_standardize`. Both `disentanglement` methods stay.
+- `standardize_targets`. It was a genuine trade-off — higher selection precision,
+  roughly half the recall — but it is superseded by
+  `stability_selection(threshold=...)` -> `stable_encoder()` -> `apply_encoder()`,
+  which is the same trade with a dial that reports what it is doing. Two knobs for
+  one trade-off is worse than one.
+
+Removed from `fit`:
+
+- `balance_obs`, and with it the `sample_weights` parameter that threaded through
+  nine methods and both stability paths. Its own documentation conceded the
+  limit: the weights never reached the `allboost` fit, so gene selection stayed
+  unbalanced no matter what they were set to. The measured effect was modest (per
+  group reconstruction-MSE spread 0.231 -> 0.150) for a mechanism that promised
+  more than it delivered.
+
+`BAE.stability_selection` is now iteration mode only; `mode`, `subsample_frac`,
+`n_subsamples` and `n_iterations` are gone, and `fit(stability_selection=...)`
+takes a bool. Iteration mode was already the default and measures the lower
+false-discovery rate (0.26 against 0.31). The subsample path stays available as
+the standalone `structboost.stability_selection`, which is where it belongs: it
+resamples cells in the Meinshausen-Buhlmann scheme and works on an `allboost`
+problem, so supervised users with no training loop to iterate over still have it.
+The Meinshausen-Buhlmann bound it reports was measured to be violated by roughly
+an order of magnitude when the targets come from a model fitted on the same
+cells, and that warning moved with it.
+
+`uns["bae"]["variance_explained"]` is now written by every fit. It used to appear
+only when a covariate argument was passed, which left the quality workflow the
+guide documents — compare it against `linear_ceiling` — raising `KeyError` on a
+plain `fit(adata)`. The metric has nothing to do with covariates; only the
+per-group breakdown does, and that stays behind the covariate guard.
+
+Two fixes found along the way: the `allboost` example in the guide passed
+`mode="standard"`, an argument `allboost` has never accepted, so it raised
+`TypeError` as written. And `disentangle_boosting_targets` projects through the
+origin, with no intercept — exact residualization only on centered targets. That
+was masked by `disentanglement_standardize`, which centered them; with the flag
+gone the assumption is documented instead.
+
+### [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.3.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.3.0"
+date-released: "2026-08-11"
 license: MIT
 authors:
   - family-names: Brunn

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: structboost
-Version: 0.1.2
+Version: 0.3.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
@@ -153,7 +153,7 @@ is not identifiable: many different sparse gene sets reconstruct the data about
 equally well, and a fit returns one of them.
 
 ```python
-res = model.stability_selection(adata, mode="iteration")
+res = model.stability_selection(adata)
 genes = [adata.var_names[res.stable_support[:, j]] for j in range(res.frequency.shape[1])]
 ```
 

{structboost-0.1.2 → structboost-0.3.0}/README.md

@@ -78,7 +78,7 @@ is not identifiable: many different sparse gene sets reconstruct the data about
 equally well, and a fit returns one of them.
 
 ```python
-res = model.stability_selection(adata, mode="iteration")
+res = model.stability_selection(adata)
 genes = [adata.var_names[res.stable_support[:, j]] for j in range(res.frequency.shape[1])]
 ```
 

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "structboost"
-version = "0.1.2"
+version = "0.3.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.3.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.3.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.3.0}/src/structboost/_decoder.py

@@ -55,11 +55,7 @@ class BAEDecoder(nn.Module):
 
         for i in range(len(dims) - 1):
             layers.append(nn.Linear(dims[i], dims[i + 1]))
-            if config.decoder_use_batch_norm:
-                layers.append(nn.BatchNorm1d(dims[i + 1]))
             layers.append(self.activation)
-            if config.decoder_dropout_rate > 0:
-                layers.append(nn.Dropout(config.decoder_dropout_rate))
 
         self.hidden = nn.Sequential(*layers)
         # Final projection to output space
@@ -83,8 +79,6 @@ class BAEDecoder(nn.Module):
         for module in self.modules():
             if isinstance(module, nn.Linear):
                 module.reset_parameters()
-            elif isinstance(module, nn.BatchNorm1d):
-                module.reset_parameters()
 
     def forward(self, z: torch.Tensor, covariates: torch.Tensor | None = None) -> torch.Tensor:
         """Decode latent representation to reconstruction.