From 76da3e1e9128d7a23530d017f26f74d03e21e4b0 Mon Sep 17 00:00:00 2001 From: Shuo Zhou Date: Fri, 21 Aug 2026 23:01:21 +0100 Subject: [PATCH 1/3] init cife and ajive --- README.md | 7 + TUTORIALS.md | 27 +++ docs/source/api_embed.rst | 12 ++ docs/source/api_transformers.rst | 10 + docs/source/introduction.rst | 4 +- kalelinear/embed.py | 4 +- kalelinear/transformer/__init__.py | 4 + kalelinear/transformer/_ajive.py | 246 ++++++++++++++++++++++ kalelinear/transformer/_cife.py | 287 ++++++++++++++++++++++++++ kalelinear/transformer/_multiblock.py | 190 +++++++++++++++++ tests/test_public_api.py | 2 + tests/transformer/test_ajive.py | 109 ++++++++++ tests/transformer/test_cife.py | 110 ++++++++++ tests/utils/test_utils.py | 34 +++ 14 files changed, 1042 insertions(+), 4 deletions(-) create mode 100644 kalelinear/transformer/_ajive.py create mode 100644 kalelinear/transformer/_cife.py create mode 100644 kalelinear/transformer/_multiblock.py create mode 100644 tests/transformer/test_ajive.py create mode 100644 tests/transformer/test_cife.py diff --git a/README.md b/README.md index 2c50427..feacd05 100644 --- a/README.md +++ b/README.md @@ -21,6 +21,8 @@ The package is part of the [PyKale](https://github.com/pykale/pykale) ecosystem - Joint Distribution Adaptation (JDA) [[3](#references)] - Balanced Distribution Adaptation (BDA) [[4](#references)] - Maximum Independence Domain Adaptation (MIDA) [[5](#references)] + - Common and Individual Feature Extraction (CIFE) [[11](#references)] + - Angle-based Joint and Individual Variation Explained (AJIVE) [[12](#references)] - Estimator models for classification: - Manifold Regularization Learning Framework (LapSVM, LapRLS) [[6](#references)] - Adaptation Regularization Learning Framework (ARSVM, ARRLS) [[7](#references)] @@ -99,6 +101,7 @@ Worked examples for the main transformers and estimators are collected in - Learn a domain-invariant embedding with TCA - Use MIDA with categorical covariates +- Extract common and individual features across groups with CIFE or AJIVE - Train a domain adaptation classifier (ARSVM, ARRLS) - Train a manifold-regularized classifier (LapSVM, LapRLS) @@ -124,6 +127,10 @@ Worked examples for the main transformers and estimators are collected in [10] Zhou, S., Luo, J., Jiang, Y., Wang, H., Lu, H. and Gong, G., 2025. [Group-specific discriminant analysis enhances detection of sex differences in brain functional network lateralization](https://academic.oup.com/gigascience/article/doi/10.1093/gigascience/giaf082/8244707). _GigaScience_, 14, p.giaf082. +[11] Zhou, G., Cichocki, A., Zhang, Y. and Mandic, D., 2016. [Group component analysis for multiblock data: Common and individual feature extraction](https://ieeexplore.ieee.org/abstract/document/7310871). _IEEE Transactions on Neural Networks and Learning Systems_, 27(11), pp.2426-2439. + +[12] Feng, Q., Jiang, M., Hannig, J. and Marron, J.S., 2018. [Angle-based joint and individual variation explained](https://www.sciencedirect.com/science/article/abs/pii/S0047259X18302831). _Journal of Multivariate Analysis_, 166, pp.241-265. + ## Other open domain adaptation repositories - [POT: Python Optimal Transport](https://github.com/rflamary/POT) diff --git a/TUTORIALS.md b/TUTORIALS.md index 320e125..075561a 100644 --- a/TUTORIALS.md +++ b/TUTORIALS.md @@ -101,3 +101,30 @@ clf = LapSVM(kernel="linear") clf.fit(X_train, ys) y_pred = clf.predict(X_target) ``` + +## Learn Common and Individual Features Across Groups + +CIFE and AJIVE decompose multiblock data into a common feature subspace shared +by all blocks plus block-specific individual subspaces. Blocks can be passed +either as a stacked matrix with a `groups` array of block ids or as a list of +block matrices sharing the same feature space. + +```python +import numpy as np +from kalelinear.transformer import CIFE, AJIVE + +rng = np.random.default_rng(0) +X = np.vstack([rng.normal(size=(50, 10)) for _ in range(3)]) +groups = np.repeat([0, 1, 2], 50) + +cife = CIFE(random_state=0) +z_common = cife.fit_transform(X, groups=groups) +z_individual = cife.transform_individual(X, groups=groups) + +ajive = AJIVE(n_resamples=50, random_state=0) +z_common_ajive = ajive.fit_transform(X, groups=groups) +``` + +`transform` returns the common feature scores of the samples, and +`transform_individual` returns a list with the block-specific individual +scores. diff --git a/docs/source/api_embed.rst b/docs/source/api_embed.rst index a3dd0dd..db8f038 100644 --- a/docs/source/api_embed.rst +++ b/docs/source/api_embed.rst @@ -35,3 +35,15 @@ the same transformer classes as :mod:`kalelinear.transformer`. :undoc-members: :show-inheritance: :no-index: + +.. autoclass:: CIFE + :members: + :undoc-members: + :show-inheritance: + :no-index: + +.. autoclass:: AJIVE + :members: + :undoc-members: + :show-inheritance: + :no-index: diff --git a/docs/source/api_transformers.rst b/docs/source/api_transformers.rst index b7db20e..f73863b 100644 --- a/docs/source/api_transformers.rst +++ b/docs/source/api_transformers.rst @@ -27,3 +27,13 @@ Transformers :members: :undoc-members: :show-inheritance: + +.. autoclass:: CIFE + :members: + :undoc-members: + :show-inheritance: + +.. autoclass:: AJIVE + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/introduction.rst b/docs/source/introduction.rst index 1611d71..c79a14d 100644 --- a/docs/source/introduction.rst +++ b/docs/source/introduction.rst @@ -14,8 +14,8 @@ covariates, side information, or unlabeled target samples. Main Features ------------- -* Transformer models for learning feature embeddings: MPCA, TCA, JDA, BDA, and - MIDA. +* Transformer models for learning feature embeddings: MPCA, TCA, JDA, BDA, + MIDA, CIFE, and AJIVE. * Estimator models for classification and adaptation: LapSVM, LapRLS, ARSVM, ARRLS, CoIRSVM, CoIRLS, and GSDA. * NumPy-compatible inputs and outputs. diff --git a/kalelinear/embed.py b/kalelinear/embed.py index a9f59b3..3cb98b5 100644 --- a/kalelinear/embed.py +++ b/kalelinear/embed.py @@ -1,5 +1,5 @@ """Embedding models exposed with a PyKale-style API.""" -from kalelinear.transformer import BDA, JDA, MIDA, MPCA, TCA +from kalelinear.transformer import AJIVE, BDA, CIFE, JDA, MIDA, MPCA, TCA -__all__ = ["TCA", "JDA", "BDA", "MIDA", "MPCA"] +__all__ = ["TCA", "JDA", "BDA", "MIDA", "MPCA", "CIFE", "AJIVE"] diff --git a/kalelinear/transformer/__init__.py b/kalelinear/transformer/__init__.py index 7a68902..b0c44bb 100644 --- a/kalelinear/transformer/__init__.py +++ b/kalelinear/transformer/__init__.py @@ -1,3 +1,5 @@ +from kalelinear.transformer._ajive import AJIVE +from kalelinear.transformer._cife import CIFE from kalelinear.transformer._jda import BDA, JDA from kalelinear.transformer._mida import MIDA from kalelinear.transformer._mpca import MPCA @@ -9,4 +11,6 @@ "BDA", "MIDA", "MPCA", + "CIFE", + "AJIVE", ] diff --git a/kalelinear/transformer/_ajive.py b/kalelinear/transformer/_ajive.py new file mode 100644 index 0000000..ce0ab11 --- /dev/null +++ b/kalelinear/transformer/_ajive.py @@ -0,0 +1,246 @@ +# ============================================================================= +# @author: Shuo Zhou, Lalu Muhammad Riza Rizky, The University of Sheffield +# @contact: shuo.zhou@sheffield.ac.uk +# ============================================================================= +"""Angle-based Joint and Individual Variation Explained (AJIVE) implementation. + +References +---------- +Feng, Q., Jiang, M., Hannig, J. and Marron, J.S., 2018. Angle-based joint and +individual variation explained. Journal of Multivariate Analysis, 166, +pp.241-265. + +The algorithm follows the authors' reference MATLAB implementation +(MeileiJiang/AJIVE_Project) with the same perturbation-bound and rank +selection steps. +""" + +from numbers import Integral, Real + +import numpy as np +from sklearn.utils._param_validation import Interval + +from kalelinear.transformer._multiblock import _check_per_block_ranks, BaseCommonIndividualTransformer + +_FERROR = 1e-10 + + +def _jive_rand_null_norm(data, basis, n_sim, random_state): + """Energy of data on random directions orthogonal to ``basis``.""" + dim = basis.shape[0] + null_norms = np.empty(n_sim) + for i in range(n_sim): + current = basis.copy() + directions = [] + for _ in range(basis.shape[1]): + direction = random_state.randn(dim) + direction = direction - current @ (current.T @ direction) + direction /= np.linalg.norm(direction) + directions.append(direction) + current = np.column_stack((current, direction)) + directions = np.column_stack(directions) + null_norms[i] = np.linalg.norm(data @ directions) + return null_norms + + +def _wedin_angle_bound(block, n_sim, U, S, V, random_state): + """Resampled Wedin perturbation-angle bound for one data block.""" + row_bound = _jive_rand_null_norm(block, V, n_sim, random_state) + column_bound = _jive_rand_null_norm(block.T, U, n_sim, random_state) + delta = S[-1] + ratio = np.maximum(row_bound, column_bound) / delta + ratio = np.clip(ratio, 0.0, 1.0) + return np.rad2deg(np.arcsin(ratio)) + + +def _random_direction_ssv(n, ranks, n_sim, random_state): + """Largest squared singular values of random stacked subspaces.""" + stacked = np.zeros((int(np.sum(ranks)), n)) + values = np.empty(n_sim) + for i in range(n_sim): + row = 0 + for rank in ranks: + Q, _ = np.linalg.qr(random_state.randn(n, rank)) + stacked[row : row + rank] = Q.T + row += rank + values[i] = np.linalg.norm(stacked, 2) ** 2 + return values + + +class AJIVE(BaseCommonIndividualTransformer): + """Angle-based Joint and Individual Variation Explained (AJIVE). + + AJIVE decomposes multiblock data into a joint (common) subspace shared by + all blocks and block-specific individual subspaces. It estimates the joint + rank from the Wedin perturbation bound of the stacked per-block row spaces + and reconstructs the joint and individual structures with low-rank SVDs. + + ``X`` can be a single matrix with a ``groups`` array of block ids, or a + list of block matrices that all share the same feature space. + :meth:`transform` returns the common feature scores of the samples while + :meth:`transform_individual` returns the block-specific individual scores. + + Parameters + ---------- + n_common_components : int or None, default=None + Number of joint components. When None, the joint rank is selected from + the Wedin perturbation bound. + n_individual_components : int, array-like or None, default=None + Number of individual components per block. When None, components above + the per-block singular-value threshold are kept. + initial_ranks : int, array-like or None, default=None + Initial signal rank of each block. When None, ranks are estimated from + the fraction of variance explained by ``variance_threshold``. + variance_threshold : float, default=0.95 + Cumulative explained-variance fraction used to estimate ``initial_ranks`` + when it is None. + n_resamples : int, default=1000 + Number of re-samples for the Wedin perturbation bound. + percentile : float, default=5 + Percentile of the Wedin bounds used for the joint rank selection. + random_state : int, RandomState or None, default=None + Random seed for the perturbation-bound re-sampling. + + Attributes + ---------- + common_components_ : ndarray of shape (n_features, n_common_components_) + Orthonormal joint feature-space basis. + individual_components_ : list of ndarray of shape (n_features, rank) + Per-block orthonormal individual feature-space bases. + common_scores_ : list of ndarray of shape (n_samples_in_block, n_common_components_) + Common scores of the training samples in each block. + individual_scores_ : list of ndarray of shape (n_samples_in_block, rank) + Individual scores of the training samples in each block. + individual_ranks_ : ndarray of shape (n_blocks,) + Number of individual components retained per block. + n_common_components_ : int + Number of joint components retained. + """ + + _parameter_constraints: dict = { + **BaseCommonIndividualTransformer._parameter_constraints, + "initial_ranks": ["array-like", Interval(Integral, 1, None, closed="left"), None], + "variance_threshold": [Interval(Real, 0, 1, closed="both")], + "n_resamples": [Interval(Integral, 1, None, closed="left")], + "percentile": [Interval(Real, 0, 100, closed="both")], + } + + def __init__( + self, + n_common_components=None, + n_individual_components=None, + initial_ranks=None, + variance_threshold=0.95, + n_resamples=1000, + percentile=5, + random_state=None, + ): + self.initial_ranks = initial_ranks + self.variance_threshold = variance_threshold + self.n_resamples = n_resamples + self.percentile = percentile + super().__init__( + n_common_components=n_common_components, + n_individual_components=n_individual_components, + random_state=random_state, + ) + + def _resolve_initial_ranks(self, blocks): + if self.initial_ranks is None: + ranks = [] + for block in blocks: + singular_values = np.linalg.svd(block, compute_uv=False) + if singular_values.size == 0: + ranks.append(0) + continue + explained = np.cumsum(singular_values**2) / np.sum(singular_values**2) + rank = int(np.searchsorted(explained, self.variance_threshold) + 1) + ranks.append(int(min(rank, singular_values.size))) + return np.asarray(ranks, dtype=int) + ranks = _check_per_block_ranks(self.initial_ranks, self.n_blocks_, "initial_ranks") + for n, (rank, block) in enumerate(zip(ranks, blocks)): + if rank < 1 or rank > min(block.shape): + raise ValueError( + f"`initial_ranks[{n}]` must be between 1 and min(samples, features) " + f"= {min(block.shape)}, got {rank}." + ) + return ranks + + def _fit_blocks(self, blocks): + D = self.n_features_in_ + ranks = self._resolve_initial_ranks(blocks) + if np.any(ranks < 1): + raise ValueError("`initial_ranks` must contain positive values for every block.") + + stacked = np.zeros((int(np.sum(ranks)), D)) + thresholds = np.empty(self.n_blocks_) + angle_bounds = [] + row = 0 + for n, block in enumerate(blocks): + rank = ranks[n] + U, s, Vt = np.linalg.svd(block, full_matrices=False) + if rank + 1 <= len(s): + thresholds[n] = 0.5 * (s[rank - 1] + s[rank]) + else: + thresholds[n] = 0.5 * s[-1] + U0, S0, V0 = U[:, :rank], s[:rank], Vt[:rank].T + stacked[row : row + rank] = V0.T + row += rank + angle_bounds.append(_wedin_angle_bound(block, self.n_resamples, U0, S0, V0, self.random_state_)) + angle_bounds = np.vstack(angle_bounds) + + _, s_stacked, Vt_stacked = np.linalg.svd(stacked, full_matrices=False) + s_stacked = s_stacked[: min(stacked.shape)] + wedin_ssv_bounds = np.maximum(np.sum(np.cos(np.deg2rad(angle_bounds)) ** 2, axis=0), 1.0) + wedin_ssv_bound = np.percentile(wedin_ssv_bounds, self.percentile) + random_ssvs = _random_direction_ssv(D, ranks, 100, self.random_state_) + random_ssv_bound = np.percentile(random_ssvs, 95) + if random_ssv_bound > np.percentile(wedin_ssv_bounds, 5): + joint_rank = int(np.sum(s_stacked**2 + _FERROR > random_ssv_bound)) + else: + joint_rank = int(np.sum(s_stacked**2 + _FERROR > wedin_ssv_bound)) + if self.n_common_components is not None: + joint_rank = min(int(self.n_common_components), len(s_stacked)) + + row_joint = Vt_stacked[:joint_rank] + drop_rows = set() + for n, block in enumerate(blocks): + projected = block @ row_joint.T + low_variance = np.flatnonzero(np.sqrt(np.sum(projected**2, axis=0)) <= thresholds[n] + _FERROR) + drop_rows.update(low_variance.tolist()) + if drop_rows: + keep_rows = [j for j in range(row_joint.shape[0]) if j not in drop_rows] + row_joint = row_joint[keep_rows] + joint_rank = row_joint.shape[0] + + common_components = row_joint.T + common_scores = [block @ common_components for block in blocks] + + ranks_spec = _check_per_block_ranks(self.n_individual_components, self.n_blocks_, "n_individual_components") + individual_components = [] + individual_scores = [] + individual_ranks = [] + for n, block in enumerate(blocks): + individual = block - block @ common_components @ common_components.T + s_individual = np.linalg.svd(individual, compute_uv=False) + if ranks_spec is None: + rank = int(np.sum(s_individual + _FERROR > thresholds[n])) + else: + rank = min(int(ranks_spec[n]), len(s_individual)) + rank = max(rank, 0) + if rank > 0: + U_i, S_i, Vt_i = np.linalg.svd(individual, full_matrices=False) + U_i, S_i, Vt_i = U_i[:, :rank], S_i[:rank], Vt_i[:rank] + individual_components.append(Vt_i.T) + individual_scores.append(U_i * S_i) + else: + individual_components.append(np.zeros((D, 0))) + individual_scores.append(np.zeros((block.shape[0], 0))) + individual_ranks.append(rank) + + self.common_components_ = common_components + self.common_scores_ = common_scores + self.individual_components_ = individual_components + self.individual_scores_ = individual_scores + self.individual_ranks_ = np.asarray(individual_ranks, dtype=int) + self.n_common_components_ = joint_rank diff --git a/kalelinear/transformer/_cife.py b/kalelinear/transformer/_cife.py new file mode 100644 index 0000000..b2236fd --- /dev/null +++ b/kalelinear/transformer/_cife.py @@ -0,0 +1,287 @@ +# ============================================================================= +# @author: Shuo Zhou, The University of Sheffield +# @contact: shuo.zhou@sheffield.ac.uk +# ============================================================================= +"""Common and Individual Feature Extraction (CIFE) implementation. + +References +---------- +Zhou, G., Cichocki, A., Zhang, Y. and Mandic, D., 2016. Group component +analysis for multiblock data: Common and individual feature extraction. +IEEE Transactions on Neural Networks and Learning Systems, 27(11), +pp.2426-2439. + +The common orthogonal basis extraction (COBE) steps follow the authors' +reference implementations (pycifa and the accompanying MATLAB code). +""" + +from numbers import Integral, Real + +import numpy as np +from sklearn.utils._param_validation import Interval + +from kalelinear.transformer._multiblock import _check_per_block_ranks, BaseCommonIndividualTransformer + + +def _column_space_basis(Y, pca_dim=None): + """Return an orthonormal basis of the column space of ``Y`` (D x J).""" + D, J = Y.shape + U, s, _ = np.linalg.svd(Y, full_matrices=False) + if s.size == 0 or s[0] == 0: + raise ValueError("Each block must have a non-zero column space.") + rank = int(np.sum(s > s[0] * max(D, J) * np.finfo(s.dtype).eps)) + if rank >= D: + if pca_dim is None: + raise ValueError( + "A block spans the whole feature space, so common and individual " + "subspaces cannot be separated. Reduce the dimensionality first " + "or set `pca_dim` to truncate the per-block column spaces." + ) + if 0 < pca_dim < 1: + rank = min(int(np.floor(D * pca_dim)), D - 1) + else: + rank = min(int(pca_dim), D - 1) + rank = max(rank, 1) + return U[:, :rank], rank + + +def _cobe_common_basis(blocks, c, max_iter, tol, epsilon, pca_dim, random_state): + """Extract a common orthogonal basis shared by all blocks. + + Parameters + ---------- + blocks : list of ndarray of shape (D, J_n) + Data blocks sharing the same feature dimension ``D``. + c : int or None + Number of common components. When None, the number is estimated from + the residual ``epsilon`` criterion. + max_iter : int + Maximum power iterations per common direction. + tol : float + Convergence tolerance for the power iterations. + epsilon : float + Residual threshold below which a direction counts as common. + pca_dim : int, float or None + Optional per-block dimensionality truncation for blocks spanning the + whole feature space. + random_state : RandomState + Random number generator for initializing the power iterations. + + Returns + ------- + common_basis : ndarray of shape (D, n_common) + Orthonormal common basis shared by all blocks. + """ + n_blocks = len(blocks) + D = blocks[0].shape[0] + bases = [] + ranks = [] + for Y in blocks: + basis, rank = _column_space_basis(Y, pca_dim=pca_dim) + bases.append(basis) + ranks.append(rank) + min_rank = min(ranks) + if min_rank == 0: + return np.zeros((D, 0)) + if c is not None and c <= 0: + return np.zeros((D, 0)) + + order = np.argsort(ranks) + projections = [np.zeros((bases[n].shape[1], min_rank)) for n in range(n_blocks)] + common_basis = np.zeros((D, min_rank)) + residuals = [] + + def _power_iteration(initial, column): + direction = initial / np.linalg.norm(initial) + for _ in range(max_iter): + previous = direction + update = np.zeros(D) + for n in range(n_blocks): + projections[n][:, column] = bases[n].T @ direction + update += bases[n] @ projections[n][:, column] + update_norm = np.linalg.norm(update) + if update_norm == 0: + break + direction = update / update_norm + if abs(previous @ direction) > 1 - tol: + break + return direction + + # Seek the first common direction. + initial = bases[order[0]] @ random_state.randn(bases[order[0]].shape[1]) + first = _power_iteration(initial, 0) + residual = 0.0 + for n in range(n_blocks): + projection = bases[n].T @ first + residual += 1 - projection @ projection + residual /= n_blocks + residuals.append(residual) + + if c is None and residual > epsilon: + return np.zeros((D, 0)) + + if c is not None: + c = min(c, min_rank) + common_basis = np.zeros((D, c)) + common_basis[:, 0] = first + residuals.extend([np.inf] * (c - 1)) + else: + common_basis[:, 0] = first + residuals.extend([np.inf] * (min_rank - 1)) + + # Seek the remaining common directions with deflation. + for j in range(1, min_rank): + if c is not None and j >= c: + break + for n in range(n_blocks): + basis = bases[n] + bases[n] = basis - np.outer(basis @ projections[n][:, j - 1], projections[n][:, j - 1]) + initial = bases[order[0]] @ random_state.randn(bases[order[0]].shape[1]) + direction = _power_iteration(initial, j) + residual = 0.0 + for n in range(n_blocks): + projection = bases[n].T @ direction + residual += 1 - projection @ projection + residual /= n_blocks + residuals[j] = residual + if c is None and residual > epsilon: + residuals[j] = np.inf + break + common_basis[:, j] = direction + + common_basis = common_basis[:, ~np.isinf(np.asarray(residuals))] + if common_basis.shape[1] > 0: + u, _, vt = np.linalg.svd(common_basis, full_matrices=False) + common_basis = u @ vt + return common_basis + + +class CIFE(BaseCommonIndividualTransformer): + """Common and Individual Feature Extraction (CIFE). + + CIFE decomposes multiblock data into a common feature subspace shared by + all blocks and block-specific individual subspaces. The common subspace is + extracted with the common orthogonal basis extraction (COBE) algorithm and + the individual subspaces are obtained from the residual of each block after + removing its common part. + + ``X`` can be a single matrix with a ``groups`` array of block ids, or a + list of block matrices that all share the same feature space. + :meth:`transform` returns the common feature scores of the samples while + :meth:`transform_individual` returns the block-specific individual scores. + + Parameters + ---------- + n_common_components : int or None, default=None + Number of common components to extract. When None, the number is + estimated automatically from the residual threshold ``epsilon``. + n_individual_components : int, array-like or None, default=None + Number of individual components per block. When None, all numerically + non-zero residual directions are kept. + max_iter : int, default=200 + Maximum power iterations for each common direction. + tol : float, default=1e-6 + Convergence tolerance for the power iterations. + epsilon : float, default=0.01 + Residual threshold used to decide whether a direction is common when + ``n_common_components`` is None. + pca_dim : int, float or None, default=None + Optional truncation of per-block column spaces, either as a relative + fraction in (0, 1) or an absolute number of components. Required when + a block spans the whole feature space. + random_state : int, RandomState or None, default=None + Random seed for initializing the power iterations. + + Attributes + ---------- + common_components_ : ndarray of shape (n_features, n_common_components_) + Orthonormal common feature-space basis. + individual_components_ : list of ndarray of shape (n_features, rank) + Per-block orthonormal individual feature-space bases. + common_scores_ : list of ndarray of shape (n_samples_in_block, n_common_components_) + Common scores of the training samples in each block. + individual_scores_ : list of ndarray of shape (n_samples_in_block, rank) + Individual scores of the training samples in each block. + individual_ranks_ : ndarray of shape (n_blocks,) + Number of individual components retained per block. + n_common_components_ : int + Number of common components retained. + """ + + _parameter_constraints: dict = { + **BaseCommonIndividualTransformer._parameter_constraints, + "max_iter": [Interval(Integral, 1, None, closed="left")], + "tol": [Interval(Real, 0, None, closed="left")], + "epsilon": [Interval(Real, 0, None, closed="left")], + "pca_dim": [ + Interval(Real, 0, 1, closed="right"), + Interval(Integral, 2, None, closed="left"), + None, + ], + } + + def __init__( + self, + n_common_components=None, + n_individual_components=None, + max_iter=200, + tol=1e-6, + epsilon=0.01, + pca_dim=None, + random_state=None, + ): + self.max_iter = max_iter + self.tol = tol + self.epsilon = epsilon + self.pca_dim = pca_dim + super().__init__( + n_common_components=n_common_components, + n_individual_components=n_individual_components, + random_state=random_state, + ) + + def _fit_blocks(self, blocks): + D = self.n_features_in_ + transposed = [block.T for block in blocks] + common_components = _cobe_common_basis( + transposed, + c=self.n_common_components, + max_iter=self.max_iter, + tol=self.tol, + epsilon=self.epsilon, + pca_dim=self.pca_dim, + random_state=self.random_state_, + ) + n_common = common_components.shape[1] + common_scores = [block @ common_components for block in blocks] + + ranks_spec = _check_per_block_ranks(self.n_individual_components, self.n_blocks_, "n_individual_components") + individual_components = [] + individual_scores = [] + individual_ranks = [] + for n, (X_n, Y_n) in enumerate(zip(blocks, transposed)): + residual = Y_n - common_components @ (common_components.T @ Y_n) + U_i, s_i, _ = np.linalg.svd(residual, full_matrices=False) + if ranks_spec is None: + if s_i.size == 0: + rank = 0 + else: + noise_tol = s_i[0] * max(residual.shape) * np.finfo(s_i.dtype).eps + rank = int(np.sum(s_i > noise_tol)) + else: + rank = min(int(ranks_spec[n]), U_i.shape[1]) + if rank > 0: + U_i = U_i[:, :rank] + individual_components.append(U_i) + individual_scores.append(X_n @ U_i) + else: + individual_components.append(np.zeros((D, 0))) + individual_scores.append(np.zeros((X_n.shape[0], 0))) + individual_ranks.append(rank) + + self.common_components_ = common_components + self.common_scores_ = common_scores + self.individual_components_ = individual_components + self.individual_scores_ = individual_scores + self.individual_ranks_ = np.asarray(individual_ranks, dtype=int) + self.n_common_components_ = n_common diff --git a/kalelinear/transformer/_multiblock.py b/kalelinear/transformer/_multiblock.py new file mode 100644 index 0000000..da45082 --- /dev/null +++ b/kalelinear/transformer/_multiblock.py @@ -0,0 +1,190 @@ +# ============================================================================= +# @author: Shuo Zhou, Lalu Muhammad Riza Rizky, The University of Sheffield +# @contact: shuo.zhou@sheffield.ac.uk +# ============================================================================= +"""Shared base classes for multiblock common and individual feature transformers.""" + +from abc import abstractmethod +from numbers import Integral + +import numpy as np +from sklearn.base import BaseEstimator, ClassNamePrefixFeaturesOutMixin, TransformerMixin +from sklearn.utils._param_validation import Interval +from sklearn.utils.validation import check_is_fitted, check_random_state + + +def _check_multiblock_input(X, groups=None): + """Validate a multiblock input and return one matrix per block. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) or list of array-like + When ``X`` is a single matrix, ``groups`` must give the block id of + each row. When ``X`` is a list, each element is one block and all + blocks must share the same feature space (columns). + groups : array-like of shape (n_samples,), default=None + Block id for each sample when ``X`` is a single stacked matrix. + + Returns + ------- + blocks : list of ndarray of shape (n_samples_in_block, n_features) + groups : ndarray of shape (n_samples,) or None + """ + if isinstance(X, (list, tuple)): + if groups is not None: + raise ValueError("`groups` must be None when `X` is a list of blocks.") + if len(X) == 0: + raise ValueError("`X` must contain at least one block.") + blocks = [] + n_features = None + for block in X: + block = np.asarray(block, dtype=float) + if block.ndim != 2: + raise ValueError("Each block in `X` must be a 2D array.") + if block.shape[0] == 0: + raise ValueError("Each block in `X` must contain at least one sample.") + if n_features is None: + n_features = block.shape[1] + elif block.shape[1] != n_features: + raise ValueError("All blocks must share the same number of features.") + blocks.append(block) + if len(blocks) < 2: + raise ValueError("At least two blocks are required for common and individual feature extraction.") + return blocks, None + + X = np.asarray(X, dtype=float) + if X.ndim != 2: + raise ValueError("`X` must be a 2D array or a list of 2D block arrays.") + if groups is None: + raise ValueError("`groups` must be provided when `X` is a single stacked matrix.") + groups = np.asarray(groups) + if groups.ndim != 1 or groups.shape[0] != X.shape[0]: + raise ValueError("`groups` must be a 1D array aligned with the rows of `X`.") + block_ids = np.unique(groups) + blocks = [X[groups == block_id] for block_id in block_ids] + if len(blocks) < 2: + raise ValueError("At least two blocks are required for common and individual feature extraction.") + if any(block.shape[0] == 0 for block in blocks): + raise ValueError("Each block must contain at least one sample.") + return blocks, groups + + +def _check_per_block_ranks(n_components, n_blocks, name): + """Validate an integer or a per-block sequence of component counts.""" + if n_components is None: + return None + if isinstance(n_components, (Integral, np.integer)): + return np.full(n_blocks, int(n_components), dtype=int) + ranks = np.asarray(n_components) + if ranks.ndim != 1 or ranks.shape[0] != n_blocks: + raise ValueError(f"{name} must be an integer or a sequence with one value per block.") + if not np.issubdtype(ranks.dtype, np.number): + raise ValueError(f"{name} must contain numeric values.") + return ranks.astype(int) + + +class BaseCommonIndividualTransformer(ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator): + """Base class for multiblock common and individual feature transformers. + + Subclasses learn a common feature subspace shared by all data blocks plus + block-specific individual subspaces, following the common and individual + feature extraction (CIFE) framework of Zhou and Cichocki (2016). + + The input convention follows the rest of ``kalelinear``: ``X`` is a sample + matrix whose rows are partitioned into blocks by ``groups``, or a list of + block matrices that all share the same feature space. + """ + + _parameter_constraints: dict = { + "n_common_components": [Interval(Integral, 0, None, closed="left"), None], + "n_individual_components": ["array-like", Interval(Integral, 0, None, closed="left"), None], + "random_state": ["random_state"], + } + + def __init__(self, n_common_components=None, n_individual_components=None, random_state=None): + self.n_common_components = n_common_components + self.n_individual_components = n_individual_components + self.random_state = random_state + + def fit(self, X, y=None, groups=None, **fit_params): + """Fit the transformer on multiblock data. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) or list of array-like + Stacked samples from all blocks, or a list of block matrices + sharing the same feature space. + y : array-like of shape (n_samples,), default=None + Ignored. Present for scikit-learn API consistency. + groups : array-like of shape (n_samples,), default=None + Block id for each sample, required when ``X`` is a single stacked + matrix. + + Returns + ------- + self : object + Fitted transformer. + """ + self._validate_params() + blocks, groups = _check_multiblock_input(X, groups) + self.n_features_in_ = blocks[0].shape[1] + self.n_blocks_ = len(blocks) + self.block_sizes_ = np.array([block.shape[0] for block in blocks]) + self.blocks_ = blocks + self.groups_ = groups + self.random_state_ = check_random_state(self.random_state) + self._fit_blocks(blocks) + self._n_features_out = self.n_common_components_ + return self + + @abstractmethod + def _fit_blocks(self, blocks): + """Run the algorithm on validated per-block matrices.""" + + def transform(self, X, groups=None): + """Project samples onto the learned common feature subspace. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) or list of array-like + New samples, either stacked or given as a list of blocks. + groups : array-like of shape (n_samples,), default=None + Ignored for the common projection. Present for API consistency. + + Returns + ------- + X_new : ndarray of shape (n_samples, n_common_components_) + Common feature scores shared by all blocks. + """ + check_is_fitted(self, "common_components_") + if isinstance(X, (list, tuple)): + blocks, _ = _check_multiblock_input(X) + X_stacked = np.vstack(blocks) + else: + X_stacked = np.asarray(X, dtype=float) + if X_stacked.ndim != 2: + raise ValueError("`X` must be a 2D array or a list of 2D block arrays.") + if X_stacked.shape[1] != self.n_features_in_: + raise ValueError(f"Expected {self.n_features_in_} features, got {X_stacked.shape[1]}.") + return X_stacked @ self.common_components_ + + def transform_individual(self, X, groups=None): + """Project samples onto the individual feature subspaces. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) or list of array-like + New samples, either stacked or given as a list of blocks. + groups : array-like of shape (n_samples,), default=None + Block id for each sample when ``X`` is a single stacked matrix. + + Returns + ------- + scores : list of ndarray + One array per block, of shape (n_samples_in_block, individual_ranks_[i]). + """ + check_is_fitted(self, "individual_components_") + blocks, _ = _check_multiblock_input(X, groups) + if any(block.shape[1] != self.n_features_in_ for block in blocks): + raise ValueError(f"Expected {self.n_features_in_} features in every block, got mismatched blocks.") + return [block @ components for block, components in zip(blocks, self.individual_components_)] diff --git a/tests/test_public_api.py b/tests/test_public_api.py index b431f3b..708c32a 100644 --- a/tests/test_public_api.py +++ b/tests/test_public_api.py @@ -10,6 +10,8 @@ def test_embed_module_exposes_transformers(): assert embed.BDA is transformer.BDA assert embed.MIDA is transformer.MIDA assert embed.MPCA is transformer.MPCA + assert embed.CIFE is transformer.CIFE + assert embed.AJIVE is transformer.AJIVE def test_predict_module_exposes_estimators(): diff --git a/tests/transformer/test_ajive.py b/tests/transformer/test_ajive.py new file mode 100644 index 0000000..7a1c467 --- /dev/null +++ b/tests/transformer/test_ajive.py @@ -0,0 +1,109 @@ +import numpy as np +import pytest +from numpy import testing +from sklearn.base import clone + +from kalelinear.transformer import AJIVE +from tests.utils.test_utils import make_common_individual_dataset + + +@pytest.fixture(scope="module") +def multiblock_data(): + return make_common_individual_dataset(random_state=0) + + +def _subspace_error(estimated, planted): + projection = planted @ planted.T + return np.linalg.norm(estimated - projection @ estimated) / np.sqrt(estimated.shape[1]) + + +def test_ajive_recovers_joint_and_individual_subspaces(multiblock_data): + X, groups, _, common_basis = multiblock_data + ajive = AJIVE(initial_ranks=[5, 6, 4], n_resamples=50, random_state=0) + ajive.fit(X, groups=groups) + + assert ajive.n_common_components_ == 2 + assert ajive.common_components_.shape == (X.shape[1], 2) + assert _subspace_error(ajive.common_components_, common_basis) < 1e-6 + testing.assert_array_equal(ajive.individual_ranks_, [3, 4, 2]) + + +def test_ajive_automatic_initial_ranks(multiblock_data): + X, groups, _, _ = multiblock_data + ajive = AJIVE(variance_threshold=1.0, n_resamples=50, random_state=0) + ajive.fit(X, groups=groups) + assert ajive.n_common_components_ == 2 + + +def test_ajive_manual_joint_rank(multiblock_data): + X, groups, _, _ = multiblock_data + ajive = AJIVE( + n_common_components=1, + initial_ranks=[5, 6, 4], + n_resamples=50, + random_state=0, + ) + ajive.fit(X, groups=groups) + assert ajive.n_common_components_ == 1 + + +def test_ajive_individual_rank_override(multiblock_data): + X, groups, _, _ = multiblock_data + ajive = AJIVE( + initial_ranks=[5, 6, 4], + n_individual_components=[2, 2, 2], + n_resamples=50, + random_state=0, + ) + ajive.fit(X, groups=groups) + testing.assert_array_equal(ajive.individual_ranks_, [2, 2, 2]) + + +def test_ajive_list_input_matches_stacked(multiblock_data): + X, groups, blocks, _ = multiblock_data + from_stacked = AJIVE(n_resamples=50, random_state=0).fit(X, groups=groups) + from_list = AJIVE(n_resamples=50, random_state=0).fit(blocks) + testing.assert_allclose(from_stacked.common_components_, from_list.common_components_) + + +def test_ajive_transform_consistency(multiblock_data): + X, groups, blocks, _ = multiblock_data + ajive = AJIVE(n_resamples=50, random_state=0) + ajive.fit(X, groups=groups) + + z = ajive.transform(X) + testing.assert_allclose(z, X @ ajive.common_components_) + testing.assert_allclose(ajive.transform(blocks), z) + + individual = ajive.transform_individual(X, groups=groups) + assert [scores.shape for scores in individual] == [(60, 3), (50, 4), (70, 2)] + individual_from_blocks = ajive.transform_individual(blocks) + for expected, actual in zip(individual, individual_from_blocks): + testing.assert_allclose(expected, actual) + + +def test_ajive_fit_transform_and_clone(multiblock_data): + X, groups, _, _ = multiblock_data + ajive = AJIVE(n_resamples=50, random_state=0) + z = ajive.fit_transform(X, groups=groups) + assert z.shape == (X.shape[0], 2) + + copied = clone(ajive) + copied.fit(X, groups=groups) + testing.assert_allclose(copied.common_components_, ajive.common_components_) + + +def test_ajive_feature_names(multiblock_data): + X, groups, _, _ = multiblock_data + ajive = AJIVE(n_resamples=50, random_state=0).fit(X, groups=groups) + testing.assert_array_equal(ajive.get_feature_names_out(), np.array(["ajive0", "ajive1"])) + + +def test_ajive_input_validation(): + X = np.ones((10, 4)) + with pytest.raises(ValueError, match="`groups` must be provided"): + AJIVE().fit(X) + with pytest.raises(ValueError, match="same number of features"): + AJIVE().fit([np.ones((5, 3)), np.ones((5, 4))]) + with pytest.raises(ValueError, match="initial_ranks"): + AJIVE(initial_ranks=[5, 6]).fit([np.ones((4, 3)), np.ones((4, 3))]) diff --git a/tests/transformer/test_cife.py b/tests/transformer/test_cife.py new file mode 100644 index 0000000..5188009 --- /dev/null +++ b/tests/transformer/test_cife.py @@ -0,0 +1,110 @@ +import numpy as np +import pytest +from numpy import testing +from sklearn.base import clone + +from kalelinear.transformer import CIFE +from tests.utils.test_utils import make_common_individual_dataset + + +@pytest.fixture(scope="module") +def multiblock_data(): + return make_common_individual_dataset(random_state=0) + + +def _subspace_error(estimated, planted): + projection = planted @ planted.T + return np.linalg.norm(estimated - projection @ estimated) / np.sqrt(estimated.shape[1]) + + +def test_cife_recovers_common_and_individual_subspaces(multiblock_data): + X, groups, _, common_basis = multiblock_data + cife = CIFE( + n_common_components=2, + n_individual_components=[3, 4, 2], + tol=1e-10, + random_state=0, + ) + cife.fit(X, groups=groups) + + assert cife.n_common_components_ == 2 + assert cife.common_components_.shape == (X.shape[1], 2) + assert _subspace_error(cife.common_components_, common_basis) < 1e-4 + testing.assert_array_equal(cife.individual_ranks_, [3, 4, 2]) + assert [components.shape[1] for components in cife.individual_components_] == [3, 4, 2] + + +def test_cife_automatic_common_rank(multiblock_data): + X, groups, _, _ = multiblock_data + cife = CIFE(tol=1e-10, random_state=0) + cife.fit(X, groups=groups) + assert cife.n_common_components_ == 2 + + +def test_cife_detects_no_common_structure(): + random_state = np.random.RandomState(1) + blocks = [random_state.randn(50, 4) @ random_state.randn(30, 4).T for _ in range(3)] + cife = CIFE(tol=1e-10, random_state=0) + cife.fit(blocks) + assert cife.n_common_components_ == 0 + assert cife.common_components_.shape == (30, 0) + + +def test_cife_list_input_matches_stacked(multiblock_data): + X, groups, blocks, _ = multiblock_data + from_stacked = CIFE(tol=1e-10, random_state=0).fit(X, groups=groups) + from_list = CIFE(tol=1e-10, random_state=0).fit(blocks) + testing.assert_allclose(from_stacked.common_components_, from_list.common_components_) + + +def test_cife_transform_consistency(multiblock_data): + X, groups, blocks, _ = multiblock_data + cife = CIFE(n_common_components=2, n_individual_components=[3, 4, 2], random_state=0) + cife.fit(X, groups=groups) + + z = cife.transform(X) + testing.assert_allclose(z, X @ cife.common_components_) + testing.assert_allclose(cife.transform(blocks), z) + + individual = cife.transform_individual(X, groups=groups) + assert [scores.shape for scores in individual] == [(60, 3), (50, 4), (70, 2)] + individual_from_blocks = cife.transform_individual(blocks) + for expected, actual in zip(individual, individual_from_blocks): + testing.assert_allclose(expected, actual) + + +def test_cife_fit_transform_and_clone(multiblock_data): + X, groups, _, _ = multiblock_data + cife = CIFE(n_common_components=2, random_state=0) + z = cife.fit_transform(X, groups=groups) + assert z.shape == (X.shape[0], 2) + + copied = clone(cife) + copied.fit(X, groups=groups) + testing.assert_allclose(copied.common_components_, cife.common_components_) + + +def test_cife_feature_names(multiblock_data): + X, groups, _, _ = multiblock_data + cife = CIFE(n_common_components=2, random_state=0).fit(X, groups=groups) + testing.assert_array_equal(cife.get_feature_names_out(), np.array(["cife0", "cife1"])) + + +def test_cife_full_rank_block_requires_pca_dim(): + random_state = np.random.RandomState(2) + blocks = [random_state.randn(40, 10) for _ in range(3)] + with pytest.raises(ValueError, match="whole feature space"): + CIFE(random_state=0).fit(blocks) + cife = CIFE(pca_dim=0.5, random_state=0) + cife.fit(blocks) + assert cife.n_common_components_ == 0 + + +def test_cife_input_validation(): + X = np.ones((10, 4)) + with pytest.raises(ValueError, match="`groups` must be provided"): + CIFE().fit(X) + with pytest.raises(ValueError, match="same number of features"): + CIFE().fit([np.ones((5, 3)), np.ones((5, 4))]) + with pytest.raises(ValueError, match="(?i)at least two blocks"): + CIFE().fit([np.ones((5, 3))]) diff --git a/tests/utils/test_utils.py b/tests/utils/test_utils.py index c1776a7..40ad217 100644 --- a/tests/utils/test_utils.py +++ b/tests/utils/test_utils.py @@ -108,3 +108,37 @@ def make_domain_shifted_dataset( domains = domains[idx] return X, y, domains + + +def make_common_individual_dataset( + n_blocks=3, + n_features=30, + n_common=2, + individual_ranks=(3, 4, 2), + n_samples=(60, 50, 70), + noise=0.0, + random_state=None, +): + """Create multiblock data with planted common and individual subspaces. + + Each block is generated as ``B_c A_c^T + B_i A_i^T (+ noise)`` where + ``A_c`` is a common feature-space basis shared by all blocks and ``A_i`` + is a block-specific basis orthogonal to ``A_c``. + """ + random_state = check_random_state(random_state) + common_basis, _ = np.linalg.qr(random_state.randn(n_features, n_common)) + blocks = [] + group_lists = [] + for k in range(n_blocks): + individual_basis, _ = np.linalg.qr(random_state.randn(n_features, individual_ranks[k])) + individual_basis -= common_basis @ (common_basis.T @ individual_basis) + individual_basis, _ = np.linalg.qr(individual_basis) + block = random_state.randn(n_samples[k], n_common) @ common_basis.T + block += random_state.randn(n_samples[k], individual_ranks[k]) @ individual_basis.T + if noise: + block += noise * random_state.randn(n_samples[k], n_features) + blocks.append(block) + group_lists.append(np.full(n_samples[k], k)) + X = np.vstack(blocks) + groups = np.concatenate(group_lists) + return X, groups, blocks, common_basis From 712472b690dd165c334e3f15dbbc373ab73569e8 Mon Sep 17 00:00:00 2001 From: Shuo Zhou Date: Mon, 24 Aug 2026 23:22:07 +0100 Subject: [PATCH 2/3] update ajive --- kalelinear/transformer/_ajive.py | 13 ++++++++++--- kalelinear/transformer/_multiblock.py | 10 ++++++++-- 2 files changed, 18 insertions(+), 5 deletions(-) diff --git a/kalelinear/transformer/_ajive.py b/kalelinear/transformer/_ajive.py index ce0ab11..0d8a653 100644 --- a/kalelinear/transformer/_ajive.py +++ b/kalelinear/transformer/_ajive.py @@ -27,15 +27,22 @@ def _jive_rand_null_norm(data, basis, n_sim, random_state): """Energy of data on random directions orthogonal to ``basis``.""" - dim = basis.shape[0] + n_ambient_dims = basis.shape[0] + if basis.shape[1] >= n_ambient_dims: + return np.zeros(n_sim) null_norms = np.empty(n_sim) for i in range(n_sim): current = basis.copy() directions = [] for _ in range(basis.shape[1]): - direction = random_state.randn(dim) + direction = random_state.randn(n_ambient_dims) direction = direction - current @ (current.T @ direction) - direction /= np.linalg.norm(direction) + norm = np.linalg.norm(direction) + while norm == 0: + direction = random_state.randn(n_ambient_dims) + direction = direction - current @ (current.T @ direction) + norm = np.linalg.norm(direction) + direction /= norm directions.append(direction) current = np.column_stack((current, direction)) directions = np.column_stack(directions) diff --git a/kalelinear/transformer/_multiblock.py b/kalelinear/transformer/_multiblock.py index da45082..ba92879 100644 --- a/kalelinear/transformer/_multiblock.py +++ b/kalelinear/transformer/_multiblock.py @@ -80,6 +80,12 @@ def _check_per_block_ranks(n_components, n_blocks, name): raise ValueError(f"{name} must be an integer or a sequence with one value per block.") if not np.issubdtype(ranks.dtype, np.number): raise ValueError(f"{name} must contain numeric values.") + if np.any(np.isnan(ranks)): + raise ValueError(f"{name} must not contain NaN values.") + if np.any(ranks < 0): + raise ValueError(f"{name} must contain non-negative values.") + if not np.all(np.equal(ranks, np.floor(ranks))): + raise ValueError(f"{name} must contain integer values.") return ranks.astype(int) @@ -130,8 +136,6 @@ def fit(self, X, y=None, groups=None, **fit_params): self.n_features_in_ = blocks[0].shape[1] self.n_blocks_ = len(blocks) self.block_sizes_ = np.array([block.shape[0] for block in blocks]) - self.blocks_ = blocks - self.groups_ = groups self.random_state_ = check_random_state(self.random_state) self._fit_blocks(blocks) self._n_features_out = self.n_common_components_ @@ -185,6 +189,8 @@ def transform_individual(self, X, groups=None): """ check_is_fitted(self, "individual_components_") blocks, _ = _check_multiblock_input(X, groups) + if len(blocks) != self.n_blocks_: + raise ValueError(f"Expected {self.n_blocks_} blocks, got {len(blocks)}.") if any(block.shape[1] != self.n_features_in_ for block in blocks): raise ValueError(f"Expected {self.n_features_in_} features in every block, got mismatched blocks.") return [block @ components for block, components in zip(blocks, self.individual_components_)] From fc4e26f7f6d676b9effba2a49402818956ec00b3 Mon Sep 17 00:00:00 2001 From: shuo-zhou~ Date: Tue, 25 Aug 2026 18:03:50 +0100 Subject: [PATCH 3/3] update for library naming convention, logo, and AJIVE --- README.md | 47 ++++++++++++++------------ docs/images/kalelinear.jpg | Bin 105127 -> 101442 bytes docs/source/index.rst | 12 +++---- docs/source/installation.rst | 2 +- docs/source/introduction.rst | 2 +- kalelinear/__init__.py | 2 +- kalelinear/transformer/_ajive.py | 8 ++--- kalelinear/transformer/_multiblock.py | 15 +++++--- tests/transformer/test_ajive.py | 14 ++++++++ tests/transformer/test_cife.py | 3 ++ tests/utils/test_utils.py | 28 +++++++++++++++ 11 files changed, 93 insertions(+), 40 deletions(-) diff --git a/README.md b/README.md index feacd05..f87a65c 100644 --- a/README.md +++ b/README.md @@ -9,30 +9,35 @@ [![PyPI version](https://img.shields.io/pypi/v/kalelinear?color=blue)](https://pypi.org/project/kalelinear/) [![PyPI downloads](https://pepy.tech/badge/kalelinear)](https://pepy.tech/project/kalelinear) -`kalelinear` is a Python library for learning harmonized or individualized models from multi-source/multi-view data in linear or reproducing kernel Hilbert spaces (RKHS). It provides NumPy-based methods for leveraging related data distributions and structural assumptions, including transfer learning, domain adaptation, manifold regularization, and group-aware learning, through a [`scikit-learn`](https://github.com/scikit-learn/scikit-learn) style API. +KaleLinear is a Python library for non-deep machine learning that learns transferable, shared, or group-specific models from data across multiple sources, groups, blocks, or views. It provides NumPy-based methods in linear or reproducing kernel Hilbert spaces (RKHS), including transfer learning, domain adaptation, manifold regularization, and group-aware learning, through a [`scikit-learn`](https://github.com/scikit-learn/scikit-learn) style API. The package is part of the [PyKale](https://github.com/pykale/pykale) ecosystem and focuses on linear and kernel methods for data characterized by covariates (e.g., domain labels, group labels, side information), unlabeled target samples, or tensor structures. -## What's included - -- Transformer models for learning feature embeddings: - - Multilinear Principal Component Analysis (MPCA) [[1](#references)] - - Transfer Component Analysis (TCA) [[2](#references)] - - Joint Distribution Adaptation (JDA) [[3](#references)] - - Balanced Distribution Adaptation (BDA) [[4](#references)] - - Maximum Independence Domain Adaptation (MIDA) [[5](#references)] - - Common and Individual Feature Extraction (CIFE) [[11](#references)] - - Angle-based Joint and Individual Variation Explained (AJIVE) [[12](#references)] -- Estimator models for classification: - - Manifold Regularization Learning Framework (LapSVM, LapRLS) [[6](#references)] - - Adaptation Regularization Learning Framework (ARSVM, ARRLS) [[7](#references)] - - Covariate Independence Regularized Learning Framework (CoIRSVM, CoIRLS) [[8](#references)][[9](#references)] - - Group-specific Discriminant Analysis (GSDA) [[9](#references)][[10](#references)] -- NumPy-compatible inputs and outputs. +## Key features + +- Feature transformation models for data embedding via `kalelinear.transformer` (PyKale-style alias: `kalelinear.embed`): + - Dimension reduction for multiview tensor data: + - Multilinear Principal Component Analysis (`MPCA`) [[1](#references)] + - Transferable / generalizable feature extraction across domains or groups: + - Transfer Component Analysis (`TCA`) [[2](#references)] + - Joint Distribution Adaptation (`JDA`) [[3](#references)] + - Balanced Distribution Adaptation (`BDA`) [[4](#references)] + - Maximum Independence Domain Adaptation (`MIDA`) [[5](#references)] + - Common (or shared or joint) and individual feature separation / extraction across groups or blocks: + - Common and Individual Feature Extraction (`CIFE`) [[11](#references)] + - Angle-based Joint and Individual Variation Explained (`AJIVE`) [[12](#references)] +- Estimator models for prediction via `kalelinear.estimator` (PyKale-style alias: `kalelinear.predict`): + - Predictive models that generalize across domains or groups: + - Manifold Regularization Learning Framework (`LapSVM`, `LapRLS`) [[6](#references)] + - Adaptation Regularization Learning Framework (`ARSVM`, `ARRLS`) [[7](#references)] + - Covariate Independence Regularized Learning Framework (`CoIRSVM`, `CoIRLS`) [[8](#references)][[9](#references)] + - Group-specific predictive models: + - Group-specific Discriminant Analysis (`GSDA`) [[9](#references)][[10](#references)] +- Lightweight: plain NumPy array inputs and outputs — no deep-learning framework or GPU required. - scikit-learn style `fit`, `transform`, `predict`, `fit_transform`, and `fit_predict` workflows where applicable. -- Optional covariate encoding for categorical domain or group labels. +- Most methods accept additional `covariates` — e.g., domain or group labels — alongside `X` and `y`, with optional one-hot encoding for categorical values; multiblock transformers (CIFE, AJIVE) take `groups` to specify block membership. -`kalelinear` requires Python 3.10 or later. Core dependencies include: +KaleLinear requires Python 3.10 or later. Core dependencies include: - [NumPy](http://www.numpy.org/) - [SciPy](https://www.scipy.org/) @@ -129,7 +134,7 @@ Worked examples for the main transformers and estimators are collected in [11] Zhou, G., Cichocki, A., Zhang, Y. and Mandic, D., 2016. [Group component analysis for multiblock data: Common and individual feature extraction](https://ieeexplore.ieee.org/abstract/document/7310871). _IEEE Transactions on Neural Networks and Learning Systems_, 27(11), pp.2426-2439. -[12] Feng, Q., Jiang, M., Hannig, J. and Marron, J.S., 2018. [Angle-based joint and individual variation explained](https://www.sciencedirect.com/science/article/abs/pii/S0047259X18302831). _Journal of Multivariate Analysis_, 166, pp.241-265. +[12] Feng, Q., Jiang, M., Hannig, J. and Marron, J.S., 2018. [Angle-based joint and individual variation explained](https://www.sciencedirect.com/science/article/pii/S0047259X1730204X). _Journal of Multivariate Analysis_, 166, pp.241-265. ## Other open domain adaptation repositories @@ -143,4 +148,4 @@ Worked examples for the main transformers and estimators are collected in ## License -`kalelinear` is released under the MIT License. See [LICENSE](LICENSE) for details. +KaleLinear is released under the MIT License. See [LICENSE](LICENSE) for details. diff --git a/docs/images/kalelinear.jpg b/docs/images/kalelinear.jpg index ffb35191ab7e187830f0a71205557a12d5583830..9f76423d23fcbfe24c53a7b3449d5ae2db5f3d2e 100644 GIT binary patch literal 101442 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 _xf%2+XV8SbLPxE^UQPRIQ4SsJu=6^ z#@+_OU@*uw_#ZO$8nH%jSS#XG_hVEh9T`j*RSF z+1az_D9o8FPnbV{zO>u|MFoQ5Ji>ee`Vb5bz9S|sDK0KakeMw*`2YN8stlPs3wvPJ zd>m#Gf}M-O&BaVTL^KctBM!4gC;a^n1`BhPz|WGDnhn2DGzYt2?Y{Dh z3?pU{*2Z7DRxY{Nh~7Vc$H6)&g(b$VO9#-UiB|UiZed6Nf357t!hWu+8Ii_eVDoTu z5lciEHL0M%xrM6;`Zsn=vT6#cpvRurx_k<`RJe5tDNlJfzTS_$J?~W|qhrm*mz_}$ zT@_^0mN%95d#;{B<~vRyvsEh62UqQVCp5Y^g>bGMIK<;_^t6S~lqqz@BTT3 zSnnyFLLyB|g_k{qn_6^Wj@N(8F|oMUNw+$B+-AUMLMC|%nUwxCg|y|B_Fo%^QLXos zeE(+0y&+w3%;7^C{ntW%`vFUMvaM!Rd8lt(3AMsT%V_@$_8l`h;ij<9`FC%6z@U#LG%Ylhk_Ix)zPh-ybAN7;-W^B2>MxB_oz>^ZTP&jnt3F%dXbxiY_k0HV_4V( z9|hQinY9;pTO^93k9&kV$?YFbBKOcoA?@CZrYU6Ft2cL!WRj1AlX!rWi2QD5uUW!V zZSO`^R?avHIf1G_y<;oXLjL$};-pChZSV!JnbmI|A{<56x5Z?@n;-iv`G<>`>5~H7e{m&rgPx&Li$;#egiO$PBju-S8+%S% zwmN)hahnEb3i;`pR>G*ZYg35P5384D*Dmm+irgvur#oeVvz}}#9aWxjfsJG;)=WdV zDGd#WAI=FAw45LQ)6e?~G)}7=e^r})B5g%)+l((x$92yyaqYQAc~!mItJ=bc9tz<< zb|_Z3>E7>g&8NSyou1n-D8m!Yt!8>7YS3skj~U!GIL0sQlzXW6%kvT@74XxG5AXNX z1HjrOM&F6|}sVD_>n?k1H4IMbP?MsW!FTO$m z7(?-HK}AmCDgW=DA=-|BpFRuQ8?hyI!T1W-`6IuNdj009m90~VFA8fNR^;4AK}EPb zW|sdo#6p0l2Tc_-F_543o_2>!n$>9u3;BBrc|HR);CvdKvMD6~C(gdIJgy@x^L0SJ z;y>GayzM&p!4DghtvQsHZGQcd2&L||h(O*FYzATE`eTa+t^_6clmJZW!3=-j;opKZ zKdqxBuI;>N%^tr7A-csYeuM6p6@)8*Qx=QRp#I@8tuWuH$vrdg*H_n?eRtCZ6_N1y z&o~lA^AE_+PsJ0m0sxYaK`vkcI9>Pn9!uJ=4)Bc^Gm!k*H<<*U3YqC48i|ab@UmS9 zGbxyX$eKDk-Dya({0V8OQGR_`t$`zDORA(OiTuC^@PY?uP|iF$KRs)lH9h2mfsH?d zH4nUYe%iesX?2qlAr(ypn1R_9JAc|>U1|T-yT2u^j;__gfCiT==dSq;r+j`*KjD+h zt}?m0Rei!uTT#pZ@C=iX|B2xHXBNFXR-Xqr4<`9-Gjm1pRz3M+f}8sU(HtxqMu5cN zz%yR|Ut8vaeCrZIHfFrUVY)sG(NXr0!Lcql3zq+k2 zd;l;tG=s_JsO3aB^$Y%__g`CsX6+3#NZ!#2ITQ_WxeCu;ESwG&-Uvzb=jNv|vmOFl zxO#Vk<)^((03)j*Bq+lF#7@UQBqr{X<(#|dAU`6CHt<`9z7il2t&B(0%GGI7Qu>{g z?1enK{TFm(^ZmWBpIg8n5xG9+Jl_0h+I47Ww-mjb_ZhY-;8AG&JIB>aNU?MyH#MWhfZK(m%S!;cy^ILclB8+G& z998yzH_esYqaIqKNor=}Hj?AfV2}eRRM3Fj_5IiA8oxiQCLtNNJtSo9z^1OBnIf}o z0cR}mhmZOV?)o0~@}jW+9+aYl@<-2)udT11ATijYegECZjbV|~w6kX77)lBAaXq%c zW$ps;{Kb+Y*!(q1Zk|x8VTes{d^l|Ucft!{{~uoGl5r~LbEoY?O9i=~X__vgyVJfa zqm7Q5h9?x`62L0>|Lg+bVc3eUDMa!|KJNHNCZWKDg2ykolxsQX{~(^W6kw3QqNW_A z-Csl8Z_sTT(NDG2{Teio?|%Ir@NB@iQ~#lDuvnj8l4)@>=>$q+&@awVxpf*R?&);? zpgzTK+{}QlqoEwxcJC)%pnUQ-zq%4`k$9T&1sxLQN+QZOlWS&%1l%fqp1k$0vIuCl zqqKD<8?37bH}&{QR<49Z(@^7r%W2GyNn19vU3MtJ{`s}_HDCK&esJgT>9QpW%9H<- zP^^(46<2y$1-uavw_gY}PzsGxc+38?Graps5Q>Co9{yz{@K4d^{fb>zpsx50g1;l- ze;n#Zp-^7-D^n2Vq#3iXuc@Pasrm{=fD}3N;W`w&0HuDg_)X-%EF8+)V^4%FS6j33 zd*TyiV2!UoYql_s_~AqNHoa4F<5kJu!4`%5-)fbOgs7oaP5_Z{C~?MAi~8 z{I~1}Rp5W}ieIXX1)zZ3410R0Av8)KXN9-!{MBjKR}T^RR~GE~1}OeZ$%h8*Z)q<- zZIoU=n~x6sd##8Ltn)LwtgjB>bu#}i8O+`FKY88q?9v6ZuLn;m$U(LBqd;)cm~(f7 z*{_&K^A!Pw$TMd6O2mJXNf-xG36T5WcFl55h$sWynJIUp7>3_xcD(I7r-Ln=?|_zp zzf_*)36vhFpV{M9A}|j4UZlX*PCsutZ9XcVLJG9VBqC*U3x`X6k)^XGYwb8{eej#Fk zfB(X5i@!E=#ds{IyWofEmt+Q-NX*N+~pF|DsjMp}B2l&R4=X+e84r z@m&S#dT4f-cKcuHge6r|Bm(>fs~Yg^O~36}syMKAz5jAsZ8Qb`QXP#takit5Je~i4 z@Pq@x({1II<4b2|k)QIIyQ_9FYCMz?p?p%=8Oj{+C(HTiza&~q>cY1u=>3-0A-;c+ zEKrc~`!2Nz(WsiK6ynCM2Ry9XQomC;9AU;BP?*DxRyMPZAY~r|<_H{NX2yAFSjwiYnDP0|eOvjVz$GB}1GJ&a z*o>cFImod(yt+h%S>9_~WH7tFKu3$rI$-XGp{h9(5Smq$78TKDa;1!#*@&-gBZr7& zM7MDeVg|f=t$L^kfo7}LiD(;#GBen+MaMpn}W-dYKlxZ+-xQmzF`pNU8&zCUv? zgDqt(IG3=9EzOa0aBfI-M$8vQ^x6;c+KUjewsXl1-H3~`&T4-%7`+pnl`0J;HJ3wF zV$xA zjDEqDrYc`YG_F%$No@Ol1iHD3&j#)CXoGbq6%u&39nKFV@DGi|>G75uhxRAn?VYf5Tm`E7PT*O|08{?Or z)-=h44FjBPcmpnd$9bvhSY5Ix{P%bJYgXyX1tH9i0+I=rZANP4KKu?n#IJT?ie@76@QY!!Bil)0(=1>lnGLfaqUf;NiOb(7j!vFK z5-m1mkT+VSIwsiWjsbngf}d53NgvM5;7|zL=$-=DPw)sywrQs6aAuEH7iG5nU}iVV zgn)cjc9Oyu>9P>F&|K7K&J+0XJSF2B7&!+_m5#Pr7aP~*NY$chDsU)%j#ReM_@92L@5%Jh*|4NfkoaR!0HPFl6%H+Bei963iS=H5MP)*_foB$oK1^ z%);<$3KpvK!I|To+gp+%ZJH6MQQA<>PBjw371K7R7cE89%>1Z|i;DOgnU3TIh=&5Dz3B8BnuOJKcUAZOS2xpN;dJdjU88 z-mAi#V1?#lShK2hv>0)cDZVaQ>M+$Z1_?evG;w*EUA9(^$%ym4LH>C)787%;()c|~ z&Ox7uQDz&tKt%hL=nzn3b;AH6qL#vOjD+xkUXMLRT#Qzq46bGq-VDew4KH?B4#}!Q ze@<{+q=WNP1iYI@k>+7jskoOe!OCl$RcYm1t8~VJ@{EfR1lokVX^Cl%qNNb)w82{h z-(FkoE($Ve3>$pj3js9sttryBXy7C4Pf0BaTwXaBXH2W{f_ycKrd8iQinwY3#4nzK zVwW6)$iyco88xa7ny&?H#K=|>fQUc-3cOg=D!U7 zbW5)J+3@3Ye&7t{{?+5-=yTn=RtYgce22*63|dYvHaCiFN2(POJ2Zqf0hc*G$thZHSWLZBZa z%rfn@C3pFyrMTG^Aew-IfF;v8%O*4zlE$KQad>hku7O6?N3*FM50CGGK)tnC5F@j6 zSuJLS`PQb}ge#t1{|{+ZEhgmvvD`SZxN^V^3)#*pgDnk7dO8oA^x6RV1X$81st>aD z8~8NNHf<|gn!QjkNMJ)H`#qV<;L;Ll6r?OO55mA4O>yo4?s;ZX2*U@04lycppaH!z z;o`b%WXvumP%7#EgjD7jf7WIxgC6^|K>%tqDF`%wZNd53RKPzL0>px<8eEU2k$sqC zlA*W`vQR0D;lJ8@Is4Wi0mC8ZmR&}=UNF}Ta#QHFSlL8=3+W&UnVam!Dm`v?9&a&7 zmn+Z(G80O2VUas~%D7^S8&mD?G@px;`ILk`7dM!V-Je;Y!t?@08OhVplps>0+-1mw6Ax%)x^p!Ti) zQg=JmxuyWSU{M4xZ7x?lQ>_cqH4E_t=5U@+=H6>3K~hcv>bp6fYOLOn$wPDqQ9QsB zI#6PYL@3Kvjl^v)Fk?$u@Y%z>4=85(L%K+N#F3lv5eksw1a$daB)X1GeEkL-(AJu& zfhP0lX+{B*J%g<}XEkHYZ+K-=*;YB>pO=MaI^3`Fn=%b=6zDvBP<`{phKc6mYmP4# z!=yf^d=?K`D@!V$-1mN-neqkO3!AEWmV4DV)YO%}Dr|4b9JpDTMvlA0uRSE}UEp+G z(`TIyk)=8k&@8EjM-El(>JI1E^>6GoYO@pzJokaxdgl^z#r_W_3P$`{b~~q#HE&~= zOf+^}GHJDZpK`~gu>H*xQd5vL8MQL-U2if}$Nbn+2MiIu#<%73*K$f?=G*AzM>(q5 z_7-Fbb@fy>c`1ueTo-csO&fJqyxqDmdf(X-t-JPH;c_u|nyQylavQ`H5zRpyZjkq+ zkFj+3&UqR=o+Y*pOniX0O&}9=5 z{ye4@+dLVe_}KwAgyvcFB4%-icuycrBP3Iv#2GNIAv4po%hsBLx3+Jf3xJF*1aIYUqoG42 zEK2-JMKqPNy!;8sQ(9xHb6dn4|JD9_f`l)EIicN~=Tc0$gV~4;%an%`(Jum$ep-i+ zDz2#zlO1;`lbeklG^X#GLW0h*aWxFQ8UTm%7z7Fr-^iYamS8cVof&cB5MLzIZ0sQd zKb^s#;G3fbhk9%!&f^7%%0Tr+G3UR~I3*zS64*C2-kGcFhPW_A?wAS1#F0!Ofq7<7 zY$Y2}HBEuY+dm5JVzGCks3%7E>vg0etNSzkWn3UYNrvGil-ahhdu&l0SDR*VwkcJi zHbY2v^6dI-uW`j51p$EZ-<41#8w9;Pyz$&*iq7g}H*v+GY;0&VfQ%ViWhlozY-lNB zaS?*@Ek(-A&4px|1CWsy85f`Yw7c#zqEcIO1;%>xDIIPSYGwjT`c zQI3M6;CiTL$>8C5z$+2Wg>=$m7n;We^`HYvNhsfY(VR{tu? ziW_rJPLPO5-xXeNQaSEC4*J>F8{wm>MeU_G>=zFw46sLvrVs%${}l+F7rRnDDmx}q z_e~*#rh6Zi?yHM!{_~OLpB@uhoPRu2Oc#$I2?~#IE3P5DCzbL{d>f0*j;7l2`3M-N z9O?&u#CRwZir_x_A;49NNOz$^0j1mQ1ad|Vj{wyQl2uMXbqs3(8cA`M2UtLN5eDf_ZZ+iPZek}<+n6t6)<7Mjl@TKEktr}C z4zZevSv4l8tF5C*#xkJVg|b-ewT)bm|LPu!qyssRG$>8NI~bCfbLf~J`x~itVrvd@ zRqF;bdz_FIpeqDqM}iJIC)ANrsU)au50Y3GQ0vFZW_1JS(Lwa1X^uBg`KQ_>)3hx* z*KUdkKK>IBh59#K1l3FLmkOZZZ4Oe^#y*^wDbdCmh8&(7Irk!)Z zBm?RiX=PbRqv9*`DhciwuHXZGKRl7WAl(aU(#=wcWQ7h&CL9k)L%F|F!(khqr#hUu zD4IioKr-oZw3B7A`O_XR@_P9JUIu55M5s7HmhX-%ij$@d0f=#2GGfpY)E;W(xY!TRh-(VA@=>iBf z1ST<(1;rvpj;BZf0NzDQXFw7k6=3YDwBG_IB$m+xN2%~L1Xu&Qe{2_W-jR_E&ID0g&jbwb*noYeAxa)?#BegM?I&hO@D|=mOtfC`6P9DRo0RZrE+K`T|YDEug~Z zy$pJw@Q?-wa*TlL8|ktk6LEyQ!L_(Bek(*Aq7eja=i-ex*$j>(SaB(QslLlWg2b0T zEUu$Pg~UTDa8cxn0cHInh);IrBc%@XVBmK4r(CkS`P)WorB?|A-aM|A zb2(3ShzEGKS|ahQ;HV7ZWM z7KtUqM@P78=@Ts5BC$On^f4b1xpI8V_ZOokweDGJ4EF2>G56V4oiWewC(i(2;ZRcW+euP_W2#CjbTSFB_- zbg8(!?z6MyX&jC?RZ~Q0HiV#vN=wXo@9tUvu$`Hgt(g%SZ=cXhnGMvei*i4S<1niN zE9DX_=zw%h!PhaleuB6Uz}oJ;%6ji6%kraqHje(6bbtgxQw>kcHOLT31=52!y{6$^_G4UN1#lvE3Mx3b`%UkgMyKKav+U3{RIBb?3Jb+5Cpy-OJk(42LwZw@gAVM5}q*(>^<3 ztPu{72vf%B0?4WW4=GXxUACaBE;h!1+=Z55$_V%Z%Ft|Nben;*O@}?auPGrwy{P~$ zCnnhCh867217a7QOw59$;*QZL@$WESQ@&^%H{%fJxHFQl@wu1=$hGoZkXt<)*`Xx% z1&hR6pnkCBmAWWUb^*TF-%iTS8sj55JgsJnAw7URDaKk+aS!IjKmxAC*he&;11=}h zfUO15vJL!w!w^VX%ID6qiCK?%5GM9rVeCBwgTO=(;CYJHC zI!YjX`N#Ie=dnYXZ81bI1g}PFcz4Ia03@>rN6s0oO49aNP# zsr}9VgkxHAUKV_Q%HeEm9f&NMAUQ=?4QIrJf?kB$dHN;o%F}Zhgt$MZfhMN%tWFYJ zl?Dt3RR;}^9v^GCMSz<4XoP-QX1dqrPn@-Lf(3QXjt62LkSdVOv8U4-Xq1Pq`)ukP6K{}at;it|;v4q{yFbuBVEHlq-z!db z%k!FaKKRI3rH}3&&rfpPVb+i-wc)ySq#zL+L{FUEc=6M+q01|;j{9*ADCUk2Wf_sU zE9|KI11E`aZN?5lz z-(eoEi5yP#+I<5F>RnPiu5k8#mpb%*h_xQCzS&+E`|Z$mOW}CY2aOxXy5THK#gy>* zg_8+X51+8-mj6t2d>&uVlCIQCZHZJYG@rO+xg&LN zTWsu5`T}N}c0D)U?cbW=(D8Yi^!R1I%l6~V{hmhe`Ny@T_-XR+72A%lx-CWOq03)| z>>XPavZa5|x840Iw<|7p7mQwBq_sCdlcWinCT94jId+RYvc4-8%aq z0jsRr@}f-kY-iZ2+q70<(k*7`*(0TCatX>{_`On%;iQPawE!4kn94I5*O4BP!CaB3_**kjet5k)dy*m z`y4zzS&kt_pxJ@)%B+B2p%5UrwCpl<9L#EQRyAJ!C?Rs<=o8BT3!t0?PQh$%L1B3t z4LVDZwMKU2JQpII?x~K^BJ8V(>U=iC#ati&>FiE(v}cJT92wj~b>2J8F{wnnF>;{> za>-qHOaprd+t0xS${h7UH<^V>)6YkBtdub~5X~Z;#KxJU^daM87^s{a?aZLSNvRV- zwq#Z(5rI+@4v3tUjA?dQD7KNd^Rkb#UOPH35nvhw1`gsHK~P)HssO?WnjxAfbO>}n zej;G_v>*k?Vz5}r2pg2AjhNLsqa`379h?9)D9jb# z7$@x(M8`0*zvQ@M%%ogP92;muTx1X!>z@b+o1$zBr9jKMi;Zl;As*bnm~VDoe07gw zQ-O97Zb27R+K0GO6OJNjj634ZGAaTDp6WAN6VHTQIpmGG+4$i3%O+~<4I8H;{$eo$7L69RM0|IS^ zN(38O$pB3QKFQ|5ArzFDhan>d0KG;Ft!=d!Dh@20sRUA3J<>^BY`hJ2imDCB>`fT; zs$FHqS!-n53i+qf3zU4Uw6akQpDxdVR0|roUj?GQHIa{Mw5sT-ng)Yd0c;uJwnc)- zJ;Fuc$ioC&aD5gxS>lj_*+fCn-?TM``>Excx{~AFAGWUe$K{&iH$7p~(xbt(>sB+; z)>-ouf@D4w%M_frwav*p8j(2C)p%VlT1O5m8NL+ylp;6cCg%#HCj2JXS4D6fh>wih zzW7`ACoj4xF_cu+IxUyp(OW{(rzg&z(bU2U`e%|WES{|Z5R!@J{le|E)A z7)|n%?WGR2WxUGI6=tjKeR7GJwIWK4Z7`ag550t&@sod`Pj1|LqpW*mNkDklAD4P8IF5Vi+c^diZVGsV~=hu;{=_60!bB))- z(r+rX!ryufTyaU6AM0T1R+8wFKenfAFvfN4WB4Qf$}JY{ZdW<8%~|_9F2vbN8(hC5 zA9<=!_vAeF%;Rc;KfbZ}q@W4#sSRP{Ic<&?rs)l=Oc3tmg@XC}Mlzp|t#x!Uf^jvcXt{A(|w+}1@$ex}mz8g4c5 z)kvgtnm2W4=eKzrokHZV%+)IlncHUi0U_N=e#_I0(SH~<;k9s#IIi|0%=i5%ib|Zf z=Y@^w&R3|ajXEyNFMW%BFBjFKDNJg6ttT6J@JW%(hTf}}O*X}ab}iX|f@8X5@~+gx zO5yIY#p8xT$JUFUjfYOJeyCh@cZXxuUIr%ftL2Hy#V=3D;TDshENOD}@#)VQ-qBz2 zyzaC{`MLe89sDllpD{WvWq-~Z*kV^>sYSS#W%EUb@N0gm*%K|nn)!RRdc0T0sDF&I z&nYkW`I56RwAxwuarT>*liv|2<6Yt{}!bheJY}CI4`kptl^uR8FONrP-Vg(!uul!X8S39&z4yF@I_Z7|>Um`r28)*AS-O6XD@|PTM?ylG# z_|jhaR+*=J**=Y+f769p2OlP- R(yavTdcH#Vq;{EL!{0@$9v&zD6f7;S^SM5x- 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 np.percentile(wedin_ssv_bounds, 5): - joint_rank = int(np.sum(s_stacked**2 + _FERROR > random_ssv_bound)) - else: - joint_rank = int(np.sum(s_stacked**2 + _FERROR > wedin_ssv_bound)) + # Take the more conservative (larger) of the two perturbation bounds, + # following the reference implementation: max(wedin, random). + joint_threshold = max(wedin_ssv_bound, random_ssv_bound) + joint_rank = int(np.sum(s_stacked**2 + _FERROR > joint_threshold)) if self.n_common_components is not None: joint_rank = min(int(self.n_common_components), len(s_stacked)) diff --git a/kalelinear/transformer/_multiblock.py b/kalelinear/transformer/_multiblock.py index ba92879..f0dacc0 100644 --- a/kalelinear/transformer/_multiblock.py +++ b/kalelinear/transformer/_multiblock.py @@ -13,7 +13,7 @@ from sklearn.utils.validation import check_is_fitted, check_random_state -def _check_multiblock_input(X, groups=None): +def _check_multiblock_input(X, groups=None, min_blocks=2): """Validate a multiblock input and return one matrix per block. Parameters @@ -24,6 +24,10 @@ def _check_multiblock_input(X, groups=None): blocks must share the same feature space (columns). groups : array-like of shape (n_samples,), default=None Block id for each sample when ``X`` is a single stacked matrix. + min_blocks : int, default=2 + Minimum number of blocks required. The common projection in + :meth:`transform` only needs one block, so callers that project new + samples can pass ``min_blocks=1``. Returns ------- @@ -48,7 +52,7 @@ def _check_multiblock_input(X, groups=None): elif block.shape[1] != n_features: raise ValueError("All blocks must share the same number of features.") blocks.append(block) - if len(blocks) < 2: + if len(blocks) < min_blocks: raise ValueError("At least two blocks are required for common and individual feature extraction.") return blocks, None @@ -62,7 +66,7 @@ def _check_multiblock_input(X, groups=None): raise ValueError("`groups` must be a 1D array aligned with the rows of `X`.") block_ids = np.unique(groups) blocks = [X[groups == block_id] for block_id in block_ids] - if len(blocks) < 2: + if len(blocks) < min_blocks: raise ValueError("At least two blocks are required for common and individual feature extraction.") if any(block.shape[0] == 0 for block in blocks): raise ValueError("Each block must contain at least one sample.") @@ -151,7 +155,8 @@ def transform(self, X, groups=None): Parameters ---------- X : array-like of shape (n_samples, n_features) or list of array-like - New samples, either stacked or given as a list of blocks. + New samples, either stacked or given as a list of blocks. A + single block is accepted for the common projection. groups : array-like of shape (n_samples,), default=None Ignored for the common projection. Present for API consistency. @@ -162,7 +167,7 @@ def transform(self, X, groups=None): """ check_is_fitted(self, "common_components_") if isinstance(X, (list, tuple)): - blocks, _ = _check_multiblock_input(X) + blocks, _ = _check_multiblock_input(X, min_blocks=1) X_stacked = np.vstack(blocks) else: X_stacked = np.asarray(X, dtype=float) diff --git a/tests/transformer/test_ajive.py b/tests/transformer/test_ajive.py index 7a1c467..79943fc 100644 --- a/tests/transformer/test_ajive.py +++ b/tests/transformer/test_ajive.py @@ -35,6 +35,17 @@ def test_ajive_automatic_initial_ranks(multiblock_data): assert ajive.n_common_components_ == 2 +def test_ajive_percentile_uses_larger_perturbation_bound(multiblock_data): + X, groups, _, _ = multiblock_data + ranks = [ + AJIVE(percentile=percentile, n_resamples=50, random_state=0).fit(X, groups=groups).n_common_components_ + for percentile in (5, 50, 95) + ] + # A larger percentile gives a non-decreasing Wedin threshold, so the joint + # rank selected from max(wedin, random-direction) bound cannot increase. + assert ranks[0] >= ranks[1] >= ranks[2] + + def test_ajive_manual_joint_rank(multiblock_data): X, groups, _, _ = multiblock_data ajive = AJIVE( @@ -74,6 +85,9 @@ def test_ajive_transform_consistency(multiblock_data): z = ajive.transform(X) testing.assert_allclose(z, X @ ajive.common_components_) testing.assert_allclose(ajive.transform(blocks), z) + single_block = ajive.transform([blocks[0]]) + testing.assert_allclose(single_block, blocks[0] @ ajive.common_components_) + testing.assert_allclose(ajive.transform((blocks[0],)), single_block) individual = ajive.transform_individual(X, groups=groups) assert [scores.shape for scores in individual] == [(60, 3), (50, 4), (70, 2)] diff --git a/tests/transformer/test_cife.py b/tests/transformer/test_cife.py index 5188009..8419829 100644 --- a/tests/transformer/test_cife.py +++ b/tests/transformer/test_cife.py @@ -65,6 +65,9 @@ def test_cife_transform_consistency(multiblock_data): z = cife.transform(X) testing.assert_allclose(z, X @ cife.common_components_) testing.assert_allclose(cife.transform(blocks), z) + single_block = cife.transform([blocks[0]]) + testing.assert_allclose(single_block, blocks[0] @ cife.common_components_) + testing.assert_allclose(cife.transform((blocks[0],)), single_block) individual = cife.transform_individual(X, groups=groups) assert [scores.shape for scores in individual] == [(60, 3), (50, 4), (70, 2)] diff --git a/tests/utils/test_utils.py b/tests/utils/test_utils.py index 40ad217..614c373 100644 --- a/tests/utils/test_utils.py +++ b/tests/utils/test_utils.py @@ -125,6 +125,18 @@ def make_common_individual_dataset( ``A_c`` is a common feature-space basis shared by all blocks and ``A_i`` is a block-specific basis orthogonal to ``A_c``. """ + individual_ranks = np.asarray(individual_ranks) + n_samples = np.asarray(n_samples) + if individual_ranks.ndim != 1 or individual_ranks.shape[0] != n_blocks: + raise ValueError( + f"`individual_ranks` must be a sequence with one rank per block: " + f"expected {n_blocks} values, got {individual_ranks.size}." + ) + if n_samples.ndim != 1 or n_samples.shape[0] != n_blocks: + raise ValueError( + f"`n_samples` must be a sequence with one sample count per block: " + f"expected {n_blocks} values, got {n_samples.size}." + ) random_state = check_random_state(random_state) common_basis, _ = np.linalg.qr(random_state.randn(n_features, n_common)) blocks = [] @@ -142,3 +154,19 @@ def make_common_individual_dataset( X = np.vstack(blocks) groups = np.concatenate(group_lists) return X, groups, blocks, common_basis + + +def test_make_common_individual_dataset_validates_block_parameters(): + with pytest.raises(ValueError, match="individual_ranks"): + make_common_individual_dataset(n_blocks=4) + with pytest.raises(ValueError, match="n_samples"): + make_common_individual_dataset(n_blocks=4, individual_ranks=(1, 2, 3, 4)) + + +def test_make_common_individual_dataset_accepts_custom_n_blocks(): + X, groups, blocks, _ = make_common_individual_dataset( + n_blocks=2, individual_ranks=(1, 2), n_samples=(20, 30), random_state=0 + ) + assert len(blocks) == 2 + assert [block.shape[0] for block in blocks] == [20, 30] + assert groups.shape == (50,)