pls_logistic — PLS-logistic regression

Group: Classification & GLM · Registry tolerance: 5.0

Description

PLS-Logistic — Logistic regression on PLS scores

From the pls4all.sklearn.PLSLogisticClassifier docstring:

PLS-Logistic: PLS scores fed into multinomial softmax IRLS.

Registry note — sklearn PLSRegression -> LogisticRegression pipeline vs pls4all’s single-pass PLS + softmax IRLS. Latent decompositions differ; parity is qualitative.

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

Bastien, P., Esposito Vinzi, V. & Tenenhaus, M. (2005). PLS generalised linear regression. Computational Statistics & Data Analysis 48(1), 17–46.

Mathematical principle

Iteratively-reweighted-least-squares PLS with a logit link function. At each iteration the current predictor is converted to a working response via \(z_i = \eta_i + (y_i - p_i) / (p_i(1 - p_i))\) where \(p_i = 1/(1 + e^{-\eta_i})\), a PLS fit is run on \((\mathbf{X}, \mathbf{z})\) with weights \(p_i(1 - p_i)\), and the linear predictor is updated.

This is the natural extension of PLS to binary / multinomial classification when class probabilities (rather than hard labels or class scores) are needed, and it generalises smoothly to GLM families beyond Bernoulli (Poisson — see pls_glm). The multinomial case extends to \(K\) classes via a softmax link.

Convergence is typically reached in 5–10 IRLS iterations. The Bastien et al. variant is closely related to Marx 1996’s Iteratively Reweighted PLS but differs in the deflation convention.

Implementation

n4m_pls_logistic_fit (in-sample only). Reference: R plsRglm 1.7.0.

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

pls4all.pls_logistic  Multinomial logistic regression 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_logistic_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_logistic_fit
with pls4all.Context() as ctx, pls4all.Config() as cfg:
    res = pls_logistic_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 PLSLogisticClassifier
mdl = PLSLogisticClassifier(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_logistic", 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_logistic(X, y, 3);
% see header of bindings/matlab/+pls4all/pls_logistic.m for full
% parameter surface:
%   res = pls_logistic(X, y_labels, n_components, n_classes)
yhat = predict(res, Xtest);

No idiomatic classdef wrapper — invoke pls4all.fit("pls_logistic", 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 -> LogisticRegression pipeline. pls4all’s PLS-Logistic does a single PLS + softmax IRLS in C; sklearn fits PLS on one-hot Y, then a multinomial LogisticRegression on the scores. Both are valid PLS-logistic pipelines but the latent decompositions differ; parity is on the decision-score shape.

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 6e-163.14 ms🏆
Python · pls4all
pls4all.python✓ bind3.34 ms
Python · external
📐ref.python_scikit_learnsource3.44 ms
BackendParity200×40 (ms)
C++ native · libn4m
pls4all.cpp.blas+omp✓ ref 6e-163.20 ms🏆
Python · pls4all
pls4all.python✓ bind3.81 ms
Python · external
📐ref.python_scikit_learnsource23.2 ms
BackendParity200×40 (ms)
C++ native · libn4m
pls4all.cpp.blas+omp✓ ref 6e-164.74 ms
Python · pls4all
pls4all.python✓ bind4.36 ms🏆
Python · external
📐ref.python_scikit_learnsource5.41 ms

See also: benchmark overview · methods index · interactive dashboard