GroupMultiNeSS 0.0.1__tar.gz

groupmultiness-0.0.1/GroupMultiNeSS/MASE.py

@@ -0,0 +1,72 @@
+import numpy as np
+from typing import List
+from utils import truncated_svd, truncated_eigen_decomposition
+
+
+def MASE(As: np.array, d_shared: int, d_individs: List[int]):
+    """
+        Compute the Multiple Adjacency Spectral Embedding (MASE) of a set of adjacency matrices, method proposed in [1].
+
+        Parameters
+        ----------
+        As : np.array
+            List of adjacency matrices to embed.
+        d_shared : int
+            Dimension of the shared latent space across all layers.
+        d_individs : List[int]
+            List of dimensions for individual latent spaces of each adjacency matrix.
+
+        Returns
+        -------
+        ps : List[np.ndarray]
+            Reconstructed matrices projected onto the shared space.
+        u_joint : np.ndarray
+            Shared latent positions.
+        rs : List[np.ndarray]
+            Latent-space representations of each adjacency matrix.
+
+        References
+        ----------
+        [1]  Arroyo, J., Athreya, A., Cape, J., Chen, G., Priebe, C. E., & Vogelstein, J. T. (2021).
+        Inference for multiple heterogeneous networks with a common invariant subspace.
+        Journal of Machine Learning Research, 22, 1‑49.
+        """
+    assert len(As) == len(d_individs)
+    us = []
+    for A, d_individ in zip(As, d_individs):
+        _, eigenvectors = truncated_eigen_decomposition(A, max_rank=d_individ)
+        us.append(eigenvectors)
+    u_joint, _, _ = truncated_svd(np.hstack(us), max_rank=d_shared)
+    rs = [u_joint.T @ A @ u_joint for A in As]
+    ps = [u_joint @ r @ u_joint.T for r in rs]
+    return ps, u_joint, rs
+
+
+def ASE(A: np.array, d: int, check_if_symmetric=True):
+    """
+    Compute the Adjacency Spectral Embedding (ASE) of a symmetric adjacency matrix.
+
+    Parameters
+    ----------
+    A : np.array
+        Symmetric adjacency matrix to embed.
+    d : int
+        Embedding dimension.
+    check_if_symmetric : bool, optional
+        Whether to check symmetry of A. Default is True.
+
+    Returns
+    -------
+    np.ndarray
+        Latent position matrix of shape (n_nodes, d).
+
+    References
+    ----------
+    Sussman, D. L., Tang, M., Fishkind, D. E., & Priebe, C. E. (2012). A consistent adjacency spectral embedding
+    for stochastic blockmodel graphs and some of its applications. Journal of Computational and Graphical Statistics
+    """
+    if check_if_symmetric:
+        assert np.allclose(A, A.T), "A should be a symmetric matrix"
+    eigvecs, eigvals, _ = truncated_svd(A, max_rank=d)
+    eigvals = np.sqrt(eigvals)
+    return eigvecs @ np.diag(eigvals)

groupmultiness-0.0.1/GroupMultiNeSS/__init__.py

@@ -0,0 +1,7 @@
+from .base import *
+from .data_generation import *
+from .group_multiness import *
+from .MASE import *
+from .multiness import *
+from .shared_space_hunting import *
+from .utils import *

groupmultiness-0.0.1/GroupMultiNeSS/base.py

@@ -0,0 +1,337 @@
+import numpy as np
+from numpy.linalg import norm
+from typing import List, Union
+from warnings import warn
+from typing import Iterable
+from multiprocessing import shared_memory
+import statsmodels.api as sm
+from more_itertools import zip_equal
+
+from .utils import sigmoid, leading_left_eigenvectors
+
+
+class SharedMemoryMatrixFitter:
+    """
+    Base class for managing parameter matrices in shared memory.
+
+    Allows storing, retrieving, and updating matrices in shared memory,
+    which can be used for parallel computations without duplicating data.
+    """
+
+    def _init_param_matrices(self, vals: Union[List[np.ndarray], np.ndarray] = None,
+                             shape: Iterable[int] = None) -> None:
+        """
+        Initialize shared memory for parameter matrices.
+
+        Parameters
+        ----------
+        vals : list of np.ndarray or np.ndarray, optional
+            Initial values for the matrices. If provided, shape is inferred.
+        shape : iterable of int, optional
+            Shape of the matrices to initialize if vals is not provided.
+
+        Notes
+        -----
+        - If both vals and shape are provided, vals take precedence and shape is ignored.
+        - Allocates shared memory of type float64 for storing matrices.
+        """
+        if shape is None:
+            assert vals is not None, "One of vals or shape arguments should berandom_seed provided!"
+            vals = np.array(vals)
+            shape = vals.shape
+        elif vals is not None:
+            warn("shape argument is not used as vals argument is provided!")
+
+        shm = shared_memory.SharedMemory(create=True, size=np.prod(shape) * 8)
+        self._param_matrices_shm = shared_memory.SharedMemory(name=shm.name)
+        self.param_matrices = np.ndarray(shape, dtype=np.float64, buffer=self._param_matrices_shm.buf)
+        if vals is not None:
+            self.param_matrices[:] = vals
+
+    def _set_matrix(self, val, idx):
+        """
+        Set a specific matrix in the shared memory.
+
+        Parameters
+        ----------
+        val : np.ndarray
+            Matrix value to set.
+        idx : int
+            Index of the matrix to update.
+        """
+        param_matrices = self.get_all_fitted_matrices()
+        param_matrices[idx] = val
+
+    def _set_matrices(self, vals, indices: Union[List[int], np.ndarray] = None):
+        """
+        Set multiple matrices in shared memory.
+
+        Parameters
+        ----------
+        vals : list[np.ndarray] or np.ndarray
+            List of matrix values to set.
+        indices : list or np.ndarray, optional
+            Indices of matrices to update. If None, all matrices are updated.
+        """
+        if indices is None:
+            indices = list(range(len(self.get_all_fitted_matrices())))
+        assert len(vals) == len(indices)
+        for idx, val in zip_equal(indices, vals):
+            self._set_matrix(val, idx)
+
+    def get_all_fitted_matrices(self):
+        """
+        Retrieve all matrices stored in shared memory.
+
+        Returns
+        -------
+        np.ndarray
+            Array backed by shared memory containing all parameter matrices.
+        """
+        return np.ndarray(self.param_matrices.shape, dtype=np.float64, buffer=self._param_matrices_shm.buf)
+
+
+class BaseMultiplexNetworksModel:
+    """
+    Base class for multiplex network models.
+
+    Handles edge distribution, loop constraints, and basic input validation.
+    """
+
+    def __init__(self, edge_distrib: str = "normal", loops_allowed: bool = True):
+        """
+        Initialize a multiplex network model.
+
+        Parameters
+        ----------
+        edge_distrib : str, default='normal'
+            Type of edge distribution ('normal' or 'bernoulli').
+        loops_allowed : bool, default=True
+            Whether self-loops are allowed in adjacency matrices.
+        """
+        self.edge_distrib = edge_distrib
+        self.loops_allowed = loops_allowed
+        if edge_distrib == "normal":
+            self.link_ = lambda x: x
+        elif edge_distrib == "bernoulli":
+            self.link_ = sigmoid
+        else:
+            raise NotImplementedError("Edge distribution should be either normal or bernoulli!")
+
+    def _validate_input(self, As: List[np.array]) -> np.ndarray:
+        """
+        Validate input adjacency matrices.
+
+        Checks for:
+        - Square matrices
+        - Consistent shape across layers
+        - Absence of loops if loops_allowed is False
+
+        Parameters
+        ----------
+        As : list of np.ndarray
+            List of adjacency matrices for each layer.
+
+        Returns
+        -------
+        np.ndarray
+            Stack of adjacency matrices as a 3D array.
+        """
+        assert As[0].shape[0] == As[0].shape[1], "adjacency matrix should have a square form"
+        assert np.all([As[0].shape == A.shape for A in As[1:]]), "networks should share the same vertex set"
+        if not self.loops_allowed:
+            assert np.all(np.hstack([np.diag(A) for A in As]) == 0), \
+                "loops present in one of adjacency matrices while loops_allowed == False"
+        self.n_nodes_ = As[0].shape[0]
+        self.n_layers_ = len(As)
+        self._param_participance_masks = self._get_param_participance_masks()
+        return np.stack(As)
+
+    def _get_param_participance_masks(self) -> np.ndarray:
+        """
+        Return masks indicating which parameters participate in each layer.
+
+        Must be implemented by subclasses.
+
+        Returns
+        -------
+        np.ndarray
+            Boolean mask array for parameter participation.
+        """
+        pass
+
+
+class BaseRefitting(BaseMultiplexNetworksModel, SharedMemoryMatrixFitter):
+    """
+    Base class for refitting latent matrices in multiplex network models.
+    """
+
+    def __init__(self, edge_distrib="normal", max_rank: int = None, loops_allowed: bool = True,
+                 refit_threshold: float = 1e-8):
+        """
+        Initialize the BaseRefitting object.
+
+        Parameters
+        ----------
+        edge_distrib : str, default="normal"
+            Type of edge distribution ('normal' or 'bernoulli').
+        max_rank : int, optional
+            Maximum rank for eigenvector-based refitting.
+        loops_allowed : bool, default=True
+            Whether self-loops are allowed in adjacency matrices.
+        refit_threshold : float, default=1e-8
+            Threshold to determine which matrices should be refitted.
+        """
+        BaseMultiplexNetworksModel.__init__(self, edge_distrib=edge_distrib, loops_allowed=loops_allowed)
+        self.max_rank = max_rank
+        self.refit_threshold = refit_threshold
+
+    @property
+    def n_fitted_matrices(self):
+        """
+        Number of matrices currently fitted in shared memory.
+
+        Returns
+        -------
+        int
+            Number of fitted matrices.
+        """
+        return len(self.get_all_fitted_matrices())
+
+    def _compute_offset(self, refit_matrix_indices) -> np.ndarray:
+        """
+        Compute offset vector for refitting.
+
+        Parameters
+        ----------
+        refit_matrix_indices : array-like
+            Indices of matrices to refit.
+
+        Returns
+        -------
+        np.ndarray
+            Offset vector for GLM refitting.
+        """
+        offsets_over_obs = []
+        obs_mask = self._param_participance_masks[refit_matrix_indices].any(0)
+        triu_indices = np.triu_indices(self.n_nodes_, k=0 if self.loops_allowed else 1)
+        for layer_particip_mask in self._param_participance_masks[:, obs_mask].T:
+            offset_indices = np.setdiff1d(np.arange(self.n_fitted_matrices)[layer_particip_mask], refit_matrix_indices)
+            obs_offset = self.get_all_fitted_matrices()[offset_indices].sum(0)[triu_indices]
+            offsets_over_obs.append(obs_offset)
+        return np.hstack(offsets_over_obs)
+
+    def _construct_refit_design_response_and_offset(self, As: np.ndarray, refit_matrix_indices: np.ndarray,
+                                                    refit_matrix_eigvecs: List[np.ndarray]):
+        """
+        Construct the design matrix, response vector, and offset for GLM refitting.
+
+        Parameters
+        ----------
+        As : np.ndarray
+            Stacked adjacency matrices.
+        refit_matrix_indices : np.ndarray
+            Indices of matrices to refit.
+        refit_matrix_eigvecs : list of np.ndarray
+            Eigenvectors for the refit matrices.
+
+        Returns
+        -------
+        tuple of np.ndarray
+            Design matrix, response vector, and offset vector for GLM fitting.
+        """
+        triu_indices = np.triu_indices(self.n_nodes_, k=0 if self.loops_allowed else 1)
+        obs_mask = self._param_participance_masks[refit_matrix_indices].any(0)
+        response = np.hstack([A[triu_indices] for A in As[obs_mask]])
+
+        param_designs = [np.stack([np.outer(evec, evec)[triu_indices] for evec in eigvecs.T], axis=-1)
+                         for eigvecs in refit_matrix_eigvecs]
+        offset = self._compute_offset(refit_matrix_indices)
+        refit_matrix_participance_masks = self._param_participance_masks[refit_matrix_indices][:, obs_mask]
+
+        design_mat = []
+        for param_design, participance_mask in zip_equal(param_designs, refit_matrix_participance_masks):
+            design_mat.append(np.vstack([param_design if participate else np.zeros_like(param_design)
+                                         for participate in participance_mask]))
+
+        present_vals_mask = ~np.isnan(response)
+        return np.hstack(design_mat)[present_vals_mask], response[present_vals_mask], offset[present_vals_mask]
+
+    @staticmethod
+    def _construct_refitted_matrices(refit_matrix_eigvecs: List[np.ndarray], refit_matrix_eigvals: np.ndarray):
+        """
+        Reconstruct matrices from eigenvectors and refitted eigenvalues.
+
+        Parameters
+        ----------
+        refit_matrix_eigvecs : list of np.ndarray
+            Eigenvectors for each refit matrix.
+        refit_matrix_eigvals : np.ndarray
+            Refitted eigenvalues from GLM.
+
+        Returns
+        -------
+        list of np.ndarray
+            Refitted matrices.
+        """
+        assert np.sum([mat.shape[1] for mat in refit_matrix_eigvecs]) == len(refit_matrix_eigvals)
+        refitted_matrices = []
+        start_idx = 0
+        for matrix_eigvec in refit_matrix_eigvecs:
+            matrix_dim = matrix_eigvec.shape[1]
+            matrix_eigvals = refit_matrix_eigvals[start_idx: start_idx + matrix_dim]
+            refit_matrix = matrix_eigvec @ np.diag(matrix_eigvals) @ matrix_eigvec.T
+            refitted_matrices.append(refit_matrix)
+            start_idx += matrix_dim
+        return refitted_matrices
+
+    def _preprocess_refit_matrix_indices(self, refit_matrix_indices=None) -> np.ndarray:
+        """
+        Preprocess the indices of matrices to refit by filtering out near-zero matrices.
+
+        Parameters
+        ----------
+        refit_matrix_indices : iterable of int, optional
+            Indices of matrices to consider for refitting.
+
+        Returns
+        -------
+        np.ndarray
+            Filtered array of matrix indices to refit.
+        """
+        if refit_matrix_indices is None:
+            refit_matrix_indices = range(self.n_fitted_matrices)
+        refit_matrix_indices = list(filter(lambda idx:
+                                           norm(self.get_all_fitted_matrices()[idx], ord=2) > self.refit_threshold,
+                                           refit_matrix_indices))  # don't refit rank zero matrices after hard-threshold
+        return np.array(refit_matrix_indices, dtype=int)
+
+    def refit(self, As: Union[List[np.array], np.array], refit_matrix_indices=None):
+        """
+        Refit parameter matrices using GLM based on current adjacency matrices.
+
+        Parameters
+        ----------
+        As : list or np.ndarray
+            Input adjacency matrices.
+        refit_matrix_indices : iterable of int, optional
+            Indices of matrices to refit. If None, all non-zero matrices are refitted.
+        """
+        As = self._validate_input(As)
+        refit_matrix_indices = self._preprocess_refit_matrix_indices(refit_matrix_indices)
+        if len(refit_matrix_indices) != 0:
+
+            refit_matrix_eigvecs = [leading_left_eigenvectors(mat, k=self.max_rank,
+                                                              eigval_threshold=self.refit_threshold)
+                                    for mat in self.get_all_fitted_matrices()[refit_matrix_indices]]
+
+            design_mat, response, offset = self._construct_refit_design_response_and_offset(
+                As=As, refit_matrix_indices=refit_matrix_indices, refit_matrix_eigvecs=refit_matrix_eigvecs)
+
+            family = sm.families.Gaussian() if self.edge_distrib == "normal" else sm.families.Binomial()
+            refit_model = sm.GLM(response, design_mat, family=family, offset=offset)
+            result = refit_model.fit()
+            refit_matrix_eigvals = result.params
+
+            refitted_matrices = self._construct_refitted_matrices(refit_matrix_eigvecs, refit_matrix_eigvals)
+            self._set_matrices(refitted_matrices, indices=refit_matrix_indices)

groupmultiness-0.0.1/GroupMultiNeSS/data_generation.py

@@ -0,0 +1,205 @@
+import numpy as np
+from typing import Union, List
+from warnings import warn
+
+from .utils import sigmoid, generate_matrices_given_pairwise_max_cosines
+
+
+class LatentPositionGenerator:
+    def __init__(self, n_nodes, n_layers, *,
+                 edge_distrib: str = "normal",
+                 noise_sigma: float = 1.,
+                 loops_allowed=True,
+                 d_shared: int = 2,
+                 d_individs: Union[List, int] = 2,
+                 s_vu: float = 0.,
+                 s_uu: float = 0.,
+                 comps_max_cosine_mat: np.array = None,
+                 min_V_max_U_eigval_ratio=None):
+
+        self.n_nodes = n_nodes
+        self.n_layers = n_layers
+        self.edge_distrib = edge_distrib
+        self.noise_sigma = noise_sigma
+        self.loops_allowed = loops_allowed
+        self.d_shared = d_shared
+        self.d_individs = d_individs
+        self.s_vu = s_vu
+        self.s_uu = s_uu
+        self.comps_max_cosine_mat = comps_max_cosine_mat
+        self.min_V_max_U_eigval_ratio = min_V_max_U_eigval_ratio
+
+    def _validate_input(self):
+        if self.edge_distrib == "normal":
+            self.link_fun = lambda x: x
+        elif self.edge_distrib == "bernoulli":
+            self.link_fun = sigmoid
+        else:
+            raise NotImplementedError("Link function should be normal or bernoulli")
+
+        if isinstance(self.d_individs, (list, np.ndarray)):
+            assert len(self.d_individs) == self.n_layers, \
+                "d_individs should have the length equal to the layers number"
+            self.d_individs_ = self.d_individs
+        else:
+            self.d_individs_ = self.d_individs * np.ones(self.n_layers, dtype=int)
+
+        if self.comps_max_cosine_mat is not None:
+            assert self.comps_max_cosine_mat.ndim == 2
+            assert np.allclose(self.comps_max_cosine_mat, self.comps_max_cosine_mat.T), \
+                "comps_max_cosine_mat matrix should be symmetric"
+            assert np.all((self.comps_max_cosine_mat >= 0) & (self.comps_max_cosine_mat <= 1))
+            assert np.allclose(np.all(np.diag(self.comps_max_cosine_mat)), 1)
+
+    def _generate_latent_spaces(self):
+        all_dims = [self.d_shared] + list(self.d_individs_)
+        if np.sum(all_dims) <= self.n_nodes:
+            if self.comps_max_cosine_mat is None:
+                vu_block = self.s_vu * np.ones((1, self.n_layers))
+                uu_block = self.s_uu * np.ones((self.n_layers, self.n_layers))
+                self.comps_max_cosine_mat = np.block([[np.eye(1), vu_block],
+                                                      [vu_block.T, uu_block]])
+                np.fill_diagonal(self.comps_max_cosine_mat, 1)
+            else:
+                assert self.comps_max_cosine_mat.shape[0] == np.sum(all_dims)
+            all_lat_spaces = generate_matrices_given_pairwise_max_cosines(self.n_nodes, ds=all_dims,
+                                                                          pairwise_cos_mat=self.comps_max_cosine_mat)
+        else:
+            warn("When n_nodes < sum of all components' dimensions, all angle constraints cannot be satisfied.")
+            all_lat_spaces = [np.random.randn(self.n_nodes, d) for d in all_dims]
+        self.V, self.Us = all_lat_spaces[0], all_lat_spaces[1:]
+
+        if self.min_V_max_U_eigval_ratio is not None:
+            max_eigval_U = np.linalg.svd(self.V, compute_uv=False)[self.d_shared - 1] / self.min_V_max_U_eigval_ratio
+            self.Us = [U / np.linalg.norm(U, ord=2) * max_eigval_U for U in self.Us]
+
+    def _compute_shared_latent_position(self):
+        self.S = self.V @ self.V.T
+
+    def _compute_individual_latent_positions(self):
+        self.Rs = np.stack([U @ U.T for U in self.Us])
+
+    def _compute_latent_positions(self):
+        self._compute_shared_latent_position()
+        self._compute_individual_latent_positions()
+        return self.S + self.Rs
+
+    def generate(self, random_seed=None):
+        self._validate_input()
+        np.random.seed(random_seed)
+        self._generate_latent_spaces()
+        self.Ps = self.link_fun(self._compute_latent_positions())
+        As = []
+
+        triu_x, triu_y = np.triu_indices(self.n_nodes, k=1)
+        for idx, P in enumerate(self.Ps):
+            if self.edge_distrib == "normal":
+                noise = self.noise_sigma * np.random.randn(self.n_nodes, self.n_nodes)
+                noise[triu_x, triu_y] = noise[triu_y, triu_x]
+                A = P + noise
+            elif self.edge_distrib == "bernoulli":
+                A = (np.random.rand(self.n_nodes, self.n_nodes) <= P).astype(float)
+                A[triu_x, triu_y] = A[triu_y, triu_x]
+            else:
+                raise NotImplementedError()
+
+            if not self.loops_allowed:
+                np.fill_diagonal(A, 0.)
+            As.append(A)
+        self.As = np.stack(As)
+
+
+class GroupLatentPositionGenerator(LatentPositionGenerator):
+    def __init__(self, n_nodes: int, n_layers: int,  *,
+                 group_indices: List[int],
+                 edge_distrib: str = "normal",
+                 noise_sigma: float = 1.,
+                 loops_allowed: bool = True,
+                 d_shared: int = 2,
+                 d_individs: Union[List, int] = 2,
+                 d_groups: Union[List, int] = 2,
+                 s_vw: float = 0.,
+                 s_vu: float = 0.,
+                 s_ww: float = 0.,
+                 s_wu: float = 0.,
+                 s_uu: float = 0.,
+                 comps_max_cosine_mat=None,
+                 min_V_max_W_eigval_ratio=None):
+
+        super().__init__(n_nodes, n_layers, edge_distrib=edge_distrib, noise_sigma=noise_sigma,
+                         loops_allowed=loops_allowed, d_shared=d_shared, d_individs=d_individs,
+                         comps_max_cosine_mat=comps_max_cosine_mat)
+
+        self.group_indices = group_indices
+        self.d_groups = d_groups
+        self.unique_groups = np.sort(np.unique(group_indices))
+        self.s_vw = s_vw
+        self.s_vu = s_vu
+        self.s_ww = s_ww
+        self.s_wu = s_wu
+        self.s_uu = s_uu
+        self.min_V_max_W_eigval_ratio = min_V_max_W_eigval_ratio
+
+    def _validate_input(self):
+        super()._validate_input()
+        assert (0 <= self.s_vw <= 1) & (0 <= self.s_uu <= 1) & (0 <= self.s_ww <= 1)
+        assert len(self.group_indices) == self.n_layers, "Number of group indices should = the number of layers"
+        assert np.all(np.sort(self.unique_groups) == np.arange(len(self.unique_groups))), \
+            "group_indices should contain ints from 0 to n_groups - 1, where n_groups is the number of distinct groups"
+        self.n_groups_ = len(self.unique_groups)
+        assert self.n_groups_ >= 2, "Number of groups should be at least 2"
+        if isinstance(self.d_groups, (list, np.ndarray)):
+            assert self.n_groups_ == len(self.d_groups), \
+                "Number of distinct groups should be the same as the length of d_groups"
+            self.d_groups_ = self.d_groups
+        else:
+            self.d_groups_ = self.d_groups * np.ones(self.n_groups_, dtype=int)
+
+    def _generate_latent_spaces(self):
+        all_dims = [self.d_shared] + list(self.d_groups_) + list(self.d_individs_)
+        if self.n_nodes >= np.sum(all_dims):
+            if self.comps_max_cosine_mat is None:
+                uu_block = self.s_uu * np.ones((self.n_layers, self.n_layers))
+                ww_block = self.s_ww * np.ones((self.n_groups_, self.n_groups_))
+                vw_block = self.s_vw * np.ones((1, self.n_groups_))
+                vu_block = self.s_vu * np.ones((1, self.n_layers))
+                wu_block = self.s_wu * np.ones((self.n_groups_, self.n_layers))
+                self.comps_max_cosine_mat = np.block([[np.eye(1), vw_block, vu_block],
+                                                      [vw_block.T, ww_block, wu_block],
+                                                      [vu_block.T, wu_block.T, uu_block]])
+                np.fill_diagonal(self.comps_max_cosine_mat, 1)
+            else:
+                assert self.comps_max_cosine_mat.shape[0] == np.sum(all_dims)
+
+            all_lat_spaces = generate_matrices_given_pairwise_max_cosines(self.n_nodes, ds=all_dims,
+                                                                          pairwise_cos_mat=self.comps_max_cosine_mat)
+        elif self.n_nodes >= self.d_shared + np.sum(self.d_groups_):
+            shared_group_dims = [self.d_shared] + list(self.d_groups_)
+            ww_block = self.s_ww * np.ones((self.n_groups_, self.n_groups_))
+            vw_block = self.s_vw * np.ones((1, self.n_groups_))
+            cos_mat = np.block([[np.eye(1), vw_block],
+                                [vw_block.T, ww_block]])
+            np.fill_diagonal(cos_mat, 1)
+            shared_group_lat_spaces = generate_matrices_given_pairwise_max_cosines(self.n_nodes, ds=shared_group_dims,
+                                                                                   pairwise_cos_mat=cos_mat)
+            all_lat_spaces = shared_group_lat_spaces + [np.random.randn(self.n_nodes, d) for d in self.d_individs_]
+        else:
+            warn("When n_nodes < sum of all components' dimensions, all angle constraints cannot be satisfied.")
+            all_lat_spaces = [np.random.randn(self.n_nodes, d) for d in all_dims]
+
+        self.V = all_lat_spaces[0]
+        self.Ws = all_lat_spaces[1: self.n_groups_ + 1]
+        self.Us = all_lat_spaces[self.n_groups_ + 1:]
+
+        if self.min_V_max_W_eigval_ratio is not None:
+            max_eigval_W = np.linalg.svd(self.V, compute_uv=False)[self.d_shared - 1] / self.min_V_max_W_eigval_ratio
+            self.Ws = [W / np.linalg.norm(W, ord=2) * max_eigval_W for W in self.Ws]
+
+    def _compute_group_latent_positions(self):
+        self.Qs = np.stack([W @ W.T for W in self.Ws])
+
+    def _compute_latent_positions(self):
+        self._compute_shared_latent_position()
+        self._compute_group_latent_positions()
+        self._compute_individual_latent_positions()
+        return self.S + self.Qs[self.group_indices] + self.Rs