pop_pls — POP-PLS (per-component operator selection)

Group: Adaptive · Registry tolerance: 1e-08

Description

POP-PLS — per-component adaptive operator selection

Registry note — POPPLS/POP-PLS uses per-component operator selection over the same compact nirs4all bank. Reference is the in-tree nirs4all POPPLSRegressor; parity is qualitative.

Parameters

Name	Type	Default	Notes
X	—	required	current public binding signature
y	—	required	current public binding signature
max_components	int	3	current public binding signature
operators	—	None	current public binding signature
cv	int	3	current public binding signature
fold_ids	—	None	current public binding signature
center_x	bool | None	None	current public binding signature
scale_x	bool | None	None	current public binding signature
center_y	bool | None	None	current public binding signature
scale_y	bool | None	None	current public binding signature
n_operators	int	9	registry benchmark cell value

Explanations

Bibliographic source

Beurier, G., Reiter, R., Noûs, C., Rouan, L. & Cornet, D. (2026). Reframing preprocessing selection as model-internal calibration in near-infrared spectroscopy: a large-scale benchmark of operator-adaptive PLS and Ridge models. arXiv:2605.13587. https://arxiv.org/abs/2605.13587.

Mathematical principle

POP-PLS (Per-Operator PLS) is the per-component ablation of AOM-PLS: each latent component may pick a different operator from the bank, rather than committing to one global operator. The setting is the same — centered \(\mathbf{X} \in \mathbb{R}^{n\times p}\), response \(\mathbf{Y}\), strict-linear bank \(\{\mathbf{A}_b\}_{b=1}^{B}\), cross-covariance matrix \(\mathbf{S} = \mathbf{X}^{\top}\mathbf{Y}\) — but the selection rule is local to each component.

Per-component greedy selection. Initialise \(\mathbf{S}^{(0)} \leftarrow \mathbf{S}\). For \(a = 1, \dots, K\):

1. Score the bank on the current deflated cross-covariance: for every \(b\) evaluate the criterion \(\mathcal{C}_a(b)\) of the SIMPLS-covariance step that would result from picking operator \(b\) at component \(a\) (covariance proxy \(\lVert\mathbf{A}_b\mathbf{S}^{(a-1)}\rVert\), K-fold CV-RMSE on the resulting prefix, or approximate PRESS — same family of criteria as AOM-PLS).

2. Pick the local minimiser \(b_a = \operatorname*{arg\,min}_b \mathcal{C}_a(b)\).

3. Extract the component \(\mathbf{r}_a = \mathbf{u}_1\!\bigl(\mathbf{A}_{b_a}\mathbf{S}^{(a-1)}\bigr)\) in transformed space and lift it back through the component-specific adjoint:

\[\mathbf{z}_a \;=\; \mathbf{A}_{b_a}^{\top}\,\mathbf{r}_a, \qquad \mathbf{t}_a = \mathbf{X}\mathbf{z}_a.\]

4. Deflate in the original space so that the next component sees a residual cross-covariance free of \(\mathbf{t}_a\):

\[\mathbf{S}^{(a)} \;=\; \bigl(\mathbf{I}_p - \mathbf{v}_a\mathbf{v}_a^{\top}\bigr)\mathbf{S}^{(a-1)}, \quad \mathbf{v}_a = \mathbf{p}_a / \lVert\mathbf{p}_a\rVert, \quad \mathbf{p}_a = \mathbf{X}^{\top}\mathbf{t}_a / \lVert\mathbf{t}_a\rVert^{2}.\]

Closed-form coefficient. With the selected sequence \((b_1, \dots, b_K)\) the model coefficients use exactly the same SIMPLS recovery formula as AOM-PLS, only with a component-dependent adjoint:

\[\mathbf{Z} = \bigl[\mathbf{A}_{b_1}^{\top}\mathbf{r}_1\;\cdots\;\mathbf{A}_{b_K}^{\top}\mathbf{r}_K\bigr], \qquad \mathbf{B} = \mathbf{Z}\bigl(\mathbf{P}^{\top}\mathbf{Z}\bigr)^{+}\mathbf{Q}^{\top}.\]

\(\mathbf{B}\) lives in the original wavelength space, so — exactly as for AOM-PLS — predictions are a single dot product \(\hat{\mathbf{Y}}(\mathbf{X}^{\star}) = \mathbf{X}^{\star}\mathbf{B}\), with no preprocessing replay at predict time. The relaxation buys wavelength-region adaptivity (the model can pick a smoother for one component and a derivative for the next), at the cost of \(B\) extra cheap left actions per component.

Appropriate uses

Population-based search over PLS model configurations when exhaustive enumeration is impractical.

Limits and validation

Stochastic search has no guarantee of the global optimum and must evaluate candidates on leakage-free validation data.

Implementation

n4m_model_selection_pop_pls_select via the Python/R/MATLAB dispatchers. Uses the same compact strict-linear bank as AOM-PLS; the per-component greedy is implemented in select_per_component (aom_nirs/pls/selection.py). Reference: git-pinned oracle nirs4all.operators.models.sklearn.aom_pls.POPPLSRegressor (sanctioned exception).

Sources and provenance

Current implementation: cpp/src/core/extra_pls.cpp.

API and bindings

C ABI (ABI 2): n4m_model_selection_pop_pls_result_destroy · n4m_model_selection_pop_pls_result_get_best_score · n4m_model_selection_pop_pls_result_get_component_scores · n4m_model_selection_pop_pls_result_get_coefficients · n4m_model_selection_pop_pls_result_get_input_coefficients · n4m_model_selection_pop_pls_result_get_intercept · n4m_model_selection_pop_pls_result_get_max_components · n4m_model_selection_pop_pls_result_get_n_operators · n4m_model_selection_pop_pls_result_get_operator_kinds · n4m_model_selection_pop_pls_result_get_predictions · n4m_model_selection_pop_pls_result_get_prefix_scores · n4m_model_selection_pop_pls_result_get_selected_n_components · n4m_model_selection_pop_pls_result_get_selected_operator_indices · n4m_model_selection_pop_pls_select. Use the linked public header for the exact signature, configuration, and result handles.

Python (verified public re-export):

from n4m.model_selection.aom_search import aom_per_component_select
result = aom_per_component_select(X, y)

Source signature: aom_per_component_select(X, y, *, max_components: int = 3, operators = None, cv: int = 3, fold_ids = None, center_x: bool | None = None, scale_x: bool | None = None, center_y: bool | None = None, scale_y: bool | None = None) (n4m/_impl/native.py).

R (source-verified): pop_pls(X, Y, max_components = 3L, n_operators = 9L, cv = 3L).

library(n4m)
result <- pop_pls(X, Y)

MATLAB / Octave (source-verified): pop_pls(X, Y, max_components, n_operators, cv).

The source signature has additional required inputs, so no example call is fabricated.

Registry parity references 📐

• 📐 nirs4all (python · python) — nirs4all in-tree · strict (rmse_rel ≤ 1e-08) — In-tree nirs4all AOM/POP estimator stack (sanctioned reference). The pls4all ABI uses the same compact strict-linear bank and contiguous folds for cross-binding determinism; nirs4all remains the qualitative algorithmic reference.

Benchmarks

Archived measurement identity. Backend labels in this table are the raw IDs recorded when the benchmark ran (including historical pls4all.* IDs). They preserve measurement provenance and do not describe a current public Python, R, or MATLAB binding; use the source-verified API and bindings section above for current entry points.

Adaptive wall-clock per cell measured against full_matrix.csv. Only backends that implement this method are listed; libraries without the method are omitted.

Verdict  ·  ✓ ref / ≈ ref / ~ shape mark a reference-gate pass at strict / relaxed / qualitative tolerance  ·  ✓ bind = archived binding-harness result agrees with the C++ baseline  ·  ⇄ cross-check = documented by-design selector/RNG/model, noncanonical API/facade convention, or secondary oracle  ·  ✗ divergent  ·  ⚠ error  ·  — not run. The fastest backend per column is marked 🏆.

Reference gate: strict — numeric equivalence (rmse_rel_tol ≤ 1e-08).

Rows tagged with 📐 are the canonical parity references for this method (declared in parity_timing.registry). C++ and external rows show reference parity; archived language-harness rows show binding parity against the C++ backend. Hover the icon for role and tolerance band.

1 thread

Backend	Parity	200×40 (ms)
C++ native · libn4m
pls4all.cpp.blas+omp	✓ ref 5e-15	6.24 ms🏆
Python · archived pls4all benchmark
pls4all.python	✓ bind	7.23 ms
pls4all.sklearn	✓ bind	6.51 ms
R · archived pls4all benchmark
pls4all.R	✓ bind	12.0 ms
pls4all.R.formula	✓ bind	12.5 ms
pls4all.R.mdatools	✓ bind	24.7 ms
pls4all.R.pls	✓ bind	13.2 ms
Python · external
📐nirs4all	source	47.8 ms

3 threads

Backend	Parity	200×40 (ms)
C++ native · libn4m
pls4all.cpp.blas+omp	✓ ref 5e-15	7.34 ms
Python · archived pls4all benchmark
pls4all.python	✓ bind	7.46 ms
pls4all.sklearn	✓ bind	6.77 ms🏆
R · archived pls4all benchmark
pls4all.R	✓ bind	13.2 ms
pls4all.R.formula	✓ bind	12.9 ms
pls4all.R.mdatools	✓ bind	10.0 ms
pls4all.R.pls	✓ bind	12.4 ms
Python · external
📐nirs4all	source	36.4 ms

10 threads

Backend	Parity	200×40 (ms)
C++ native · libn4m
pls4all.cpp.blas+omp	✓ ref 5e-15	15.3 ms
Python · archived pls4all benchmark
pls4all.python	✓ bind	11.1 ms
pls4all.sklearn	✓ bind	7.06 ms🏆
R · archived pls4all benchmark
pls4all.R	✓ bind	34.2 ms
pls4all.R.formula	✓ bind	22.8 ms
pls4all.R.mdatools	✓ bind	13.5 ms
pls4all.R.pls	✓ bind	12.5 ms
Python · external
📐nirs4all	source	38.6 ms

---

See also: benchmark overview · methods index · interactive dashboard