pls_lda — PLS-LDA

Group: Classification & GLM · Registry tolerance: 5.0

Description

PLS-LDA — LDA on PLS scores (§17 Phase 4)

From the pls4all.sklearn.PLSLDAClassifier docstring:

PLS-LDA on PLS scores (in-sample only).

Registry note — sklearn PLSRegression(scale=False) -> LinearDiscriminantAnalysis is the canonical reference. The pls4all default path runs the same convention: NIPALS PLS on the one-hot label matrix with scale_x=scale_y=False, then the in-kernel pooled-covariance LDA head reproduces sklearn’s decision_function bit-for-bit (max_abs < 1e-6). Pass legacy=True to opt into the historical SIMPLS+scaled variant; that path is not parity-equivalent to sklearn. R plsVarSel::lda_from_pls exists but its return shape differs from pls4all’s decision_scores.

Parameters

Name

Type

Default

Notes

n_components

int

2

Number of latent components extracted (k).

n_classes

int

3

registry benchmark cell value

Explanations

Bibliographic source

Barker, M. & Rayens, W. (2003). Partial least squares for discrimination. Journal of Chemometrics 17(3), 166–173.

Mathematical principle

PLS-LDA is a two-stage classifier: first project \(\mathbf{X}\) into the PLS latent space using one-hot encoded class labels as \(\mathbf{Y}\), then fit Linear Discriminant Analysis on the resulting scores \(\mathbf{T} = \mathbf{X}\mathbf{W}\).

LDA in the latent space is well-conditioned (the score matrix has \(k \ll p\) columns by construction), and the PLS projection has already aligned the latent axes with the class separation direction. This is more robust than applying LDA directly to high-dimensional \(\mathbf{X}\), where the within-class covariance is singular.

The decision boundary is linear in the latent space (and therefore also linear in the original feature space via \(\mathbf{W}\)). For non-linear class boundaries use PLS-QDA or PLS-logistic.

Implementation

n4m_pls_lda_fit. The reference is composite (sklearn PLSRegression + sklearn LinearDiscriminantAnalysis); no library exposes a single PLS-LDA call.

MATLAB header (bindings/matlab/+pls4all/pls_lda.m):

pls4all.pls_lda  Linear Discriminant Analysis on PLS scores.

Usage

Every pls4all binding tab dispatches into the same C kernel; the external libraries listed at the bottom of the page are the parity references registered in benchmarks.parity_timing.registry. Switch tabs to read the same fit in your language. The R package now ships drop-in-compatible facades for the CRAN pls package (plsr, pcr, mvr) and for the mdatools::pls(x, y, ...) matrix idiom — those tabs appear only on the methods that have a meaningful equivalence.

pls4all bindings

/* C ABI — libn4m */
n4m_context_t* ctx = n4m_context_create();
n4m_config_t*  cfg = n4m_config_create();
n4m_method_result_t* res = NULL;
n4m_pls_lda_fit(ctx, cfg, &x_view, &y_view, /* hyperparams */, &res);
/* … read coefficients / mask / scores via */
/* n4m_method_result_get_double_matrix / vector / scalar … */
n4m_method_result_destroy(res);
n4m_config_destroy(cfg);
n4m_context_destroy(ctx);

import pls4all
from pls4all._methods import pls_lda_fit
with pls4all.Context() as ctx, pls4all.Config() as cfg:
    res = pls_lda_fit(ctx, cfg, X, y, n_components=3, y_labels=y_labels)
# then: res.matrix("predictions"), res.matrix("coefficients"),
# res.vector("mask"), res.scalar("intercept"), …

from pls4all.sklearn import PLSLDAClassifier
mdl = PLSLDAClassifier(n_components=2)
mdl.fit(X, y)
y_hat = mdl.predict(X_test)

library(pls4all)
# Unified low-level dispatcher (May 2026 R cleanup):
res <- pls4all_method("pls_lda", X, y,
                      n_components = 3L, params = list(n_classes = 3L))
# res is a named list with MethodResult arrays/scalars.
# selected_indices / top_k_intervals are 1-based.

res = pls4all.pls_lda(X, y, 3);
% see header of bindings/matlab/+pls4all/pls_lda.m for full
% parameter surface:
%   res = pls_lda(X, y_labels, n_components, n_classes)
yhat = predict(res, Xtest);

No idiomatic classdef wrapper — invoke pls4all.fit("pls_lda", X, y, …) directly from the unified MEX factory.

Registry parity references 📐

  • 📐 ref.python_scikit_learn (python · python) — scikit-learn 1.8.0 · qualitative (rmse_rel ≤ 5e+00) — sklearn PLSRegression -> LinearDiscriminantAnalysis pipeline. pls4all’s PLS-LDA uses a single SIMPLS pass with an internal LDA head; sklearn fits PLS on dummy-encoded targets and feeds the scores into LDA — both are LDA on PLS scores but the latent bases diverge. We compare class boundaries via one-hot decision scores.

Benchmarks

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 = pls4all binding 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; pls4all language bindings show binding parity against the C++ backend. Hover the icon for role and tolerance band.

BackendParity200×40 (ms)
C++ native · libn4m
pls4all.cpp.blas+omp✓ ref 3e-163.14 ms🏆
Python · pls4all
pls4all.python✓ bind7.48 ms
Python · external
📐ref.python_scikit_learnsource7.32 ms
BackendParity200×40 (ms)
C++ native · libn4m
pls4all.cpp.blas+omp✓ ref 3e-166.86 ms
Python · pls4all
pls4all.python✓ bind4.05 ms🏆
Python · external
📐ref.python_scikit_learnsource4.54 ms
BackendParity200×40 (ms)
C++ native · libn4m
pls4all.cpp.blas+omp✓ ref 3e-161.95 ms🏆
Python · pls4all
pls4all.python✓ bind2.67 ms
Python · external
📐ref.python_scikit_learnsource3.59 ms

See also: benchmark overview · methods index · interactive dashboard