GroupMultiNeSS 0.0.2__tar.gz → 0.0.4__tar.gz

{groupmultiness-0.0.2 → groupmultiness-0.0.4}/GroupMultiNeSS/MASE.py

@@ -1,6 +1,7 @@
 import numpy as np
 from typing import List
-from utils import truncated_svd, truncated_eigen_decomposition
+
+from .utils import truncated_svd, truncated_eigen_decomposition
 
 
 def MASE(As: np.array, d_shared: int, d_individs: List[int]):
@@ -42,7 +43,8 @@ def MASE(As: np.array, d_shared: int, d_individs: List[int]):
     return ps, u_joint, rs
 
 
-def ASE(A: np.array, d: int, check_if_symmetric=True):
+def ASE(A: np.array, d: int, check_if_symmetric: bool = True,
+        indef_inner_prod: bool = True, return_signature=False):
     """
     Compute the Adjacency Spectral Embedding (ASE) of a symmetric adjacency matrix.
 
@@ -54,6 +56,11 @@ def ASE(A: np.array, d: int, check_if_symmetric=True):
         Embedding dimension.
     check_if_symmetric : bool, optional
         Whether to check symmetry of A. Default is True.
+    indef_inner_prod: bool, optional
+        If True, indefinite inner product with signature (p, d - p)  is assumed (GRDPG model).
+        If False, standard inner product is assumed (RDPG model)
+    return_signature: bool, optional
+        Whether to return_signature of the inner product. Only used when indef_inner_prod is TrueDefault is False.
 
     Returns
     -------
@@ -67,6 +74,14 @@ def ASE(A: np.array, d: int, check_if_symmetric=True):
     """
     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)
+    eigvals, eigvecs = truncated_eigen_decomposition(A, max_rank=d, which="LM" if indef_inner_prod else "LA")
+    if indef_inner_prod:
+        sort_idx = np.argsort(eigvals)[::-1]
+        eigvals = eigvals[sort_idx]
+        eigvecs = eigvecs[:, :sort_idx]
+        signature = np.where(eigvals > 0, 1., -1)
+        ase = eigvecs @ np.diag(np.sqrt(np.abs(eigvals)))
+        return (ase, signature) if return_signature else ase
+    else:
+        ase = eigvecs @ np.diag(np.sqrt(np.clip(eigvals, a_min=0, a_max=None)))
+        return ase

{groupmultiness-0.0.2 → groupmultiness-0.0.4}/GroupMultiNeSS/data_generation.py

@@ -6,6 +6,39 @@ from .utils import sigmoid, generate_matrices_given_pairwise_max_cosines
 
 
 class LatentPositionGenerator:
+    """
+    Generator of latent positions for MultiNeSS model.
+
+    This class simulates multiple network layers that share a common latent component and
+    layer-specific deviations. It supports normal and Bernoulli edge generation models
+    and can impose angle constraints between latent spaces.
+
+    Parameters
+    ----------
+    n_nodes : int
+        Number of nodes in each network layer.
+    n_layers : int
+        Number of network layers to generate.
+    edge_distrib : {'normal', 'bernoulli'}, default='normal'
+        Type of edge distribution. If 'normal', edges are generated with Gaussian noise.
+        If 'bernoulli', edges are drawn as Bernoulli random variables.
+    noise_sigma : float, default=1.0
+        Standard deviation of the Gaussian noise for normal-distributed edges.
+    loops_allowed : bool, default=True
+        Whether self-loops (diagonal entries) are allowed.
+    d_shared : int, default=2
+        Dimension of the shared latent space component.
+    d_individs : int or list of int, default=2
+        Dimension(s) of the individual latent spaces for each layer.
+    s_vu : float, default=0.0
+        Target cosine similarity between shared and individual latent components.
+    s_uu : float, default=0.0
+        Target cosine similarity among individual latent components.
+    comps_max_cosine_mat : np.ndarray, optional
+        Custom cosine similarity matrix between components.
+    min_V_max_U_eigval_ratio : float, optional
+        Ratio to scale individual latent components relative to the shared component.
+    """
     def __init__(self, n_nodes, n_layers, *,
                  edge_distrib: str = "normal",
                  noise_sigma: float = 1.,
@@ -110,6 +143,36 @@ class LatentPositionGenerator:
 
 
 class GroupLatentPositionGenerator(LatentPositionGenerator):
+    """
+    Generator of latent positions for GroupMultiNeSS model.
+
+    Parameters
+    ----------
+    n_nodes : int
+        Number of nodes in each network layer.
+    n_layers : int
+        Number of network layers to generate.
+    group_indices : list of int
+        Group index for each layer, specifying which group latent component applies.
+    edge_distrib : {'normal', 'bernoulli'}, default='normal'
+        Type of edge distribution for generated networks.
+    noise_sigma : float, default=1.0
+        Standard deviation of Gaussian noise for normal-distributed edges.
+    loops_allowed : bool, default=True
+        Whether self-loops (diagonal entries) are allowed.
+    d_shared : int, default=2
+        Dimension of the shared latent space component.
+    d_individs : int or list of int, default=2
+        Dimension(s) of individual latent spaces for each layer.
+    d_groups : int or list of int, default=2
+        Dimension(s) of group-specific latent spaces.
+    s_vw, s_vu, s_ww, s_wu, s_uu : float, default=0.0
+        Target cosine similarities among shared, group, and individual components.
+    comps_max_cosine_mat : np.ndarray, optional
+        Predefined cosine similarity matrix among all latent components.
+    min_V_max_W_eigval_ratio : float, optional
+        Ratio to scale group latent spaces relative to the shared component.
+    """
     def __init__(self, n_nodes: int, n_layers: int,  *,
                  group_indices: List[int],
                  edge_distrib: str = "normal",

{groupmultiness-0.0.2 → groupmultiness-0.0.4}/GroupMultiNeSS/group_multiness.py

@@ -11,7 +11,6 @@ from .utils import if_scalar_or_given_length_array, fill_diagonals, \
     soft_thresholding_operator
 
 
-
 class BaseGroupMultiNeSS(BaseMultiNeSS):
     """
     Base class for group-structured MultiNeSS models.

{groupmultiness-0.0.2 → groupmultiness-0.0.4}/GroupMultiNeSS/utils.py

@@ -1,8 +1,8 @@
 import numpy as np
-from scipy.sparse.linalg import svds
+from scipy.sparse.linalg import svds, eigsh
 from typing import List, Union, Tuple
 from copy import copy
-from scipy.sparse.linalg import eigsh
+from scipy.linalg import sqrtm
 from sklearn.model_selection import KFold
 
 
@@ -197,18 +197,13 @@ def soft_thresholding_operator(A, threshold, max_rank=None):
     return u @ np.diag(s) @ vt
 
 
-def matrix_power(A: np.array, p: Union[int, float], eps=1e-8):
-    if isinstance(p, int):
-        return np.linalg.matrix_power(A, p)
-    u, s, vt = np.linalg.svd(A)
-    assert np.all(s > eps), "float powers defined only for matrices with all positive singular values"
-    return u @ np.diag(s ** p) @ vt
-
-
 def frobenius_error(A_true, A_pred, relative=False, include_offdiag=True):
     assert A_true.shape == A_pred.shape
     assert A_true.ndim <= 2
-    mask = np.ones(A_true.shape, dtype=bool) if include_offdiag else ~np.eye(A_true.shape[0], dtype=bool)
+    if include_offdiag or A_true.ndim == 1:
+        mask = np.ones(A_true.shape, dtype=bool)
+    else:
+        mask = ~np.eye(A_true.shape[0], dtype=bool)
     abs_error = np.sqrt(np.sum((A_true - A_pred) ** 2, where=mask))
     return abs_error / np.sqrt(np.sum(A_true ** 2,  where=mask)) if relative else abs_error
 
@@ -280,7 +275,9 @@ def rectangular_eye(n: int, d: int):
     return eye
 
 
-def generate_matrices_given_pairwise_max_cosines(n: int, ds: list[int], pairwise_cos_mat: np.ndarray):
+def generate_matrices_given_pairwise_max_cosines(n: int,
+                                                 ds: list[int], pairwise_cos_mat: np.ndarray,
+                                                 eps=1e-6):
     assert pairwise_cos_mat.ndim == 2
     assert len(ds) == len(pairwise_cos_mat)
     assert np.allclose(pairwise_cos_mat, pairwise_cos_mat.T), "pairwise_cos_mat should be symmetric"
@@ -288,11 +285,16 @@ def generate_matrices_given_pairwise_max_cosines(n: int, ds: list[int], pairwise
     assert np.allclose(np.diag(pairwise_cos_mat), 1)
     assert np.all(pairwise_cos_mat >= 0) & np.all(pairwise_cos_mat <= 1), "pairwise_cos_mat entries should be in [0, 1]"
     m = len(ds)
-    stacked_Vs = np.random.randn(n, np.sum(ds))
+    d_total = sum(ds)
+    stacked_Vs = np.random.randn(n, d_total)
     cur_gram_mat = stacked_Vs.T @ stacked_Vs / n
     target_gram_mat = np.block([[pairwise_cos_mat[i, j] * rectangular_eye(ds[i], ds[j]) for j in range(m)]
                                 for i in range(m)])
-    stacked_Vs = stacked_Vs @ matrix_power(cur_gram_mat, -0.5) @ matrix_power(target_gram_mat, 0.5)
+
+    sqrt_cur_gram_mat = np.real(sqrtm(cur_gram_mat + eps * np.eye(d_total)))
+    sqrt_target_gram_mat = np.real(sqrtm(target_gram_mat + eps * np.eye(d_total)))
+
+    stacked_Vs = stacked_Vs @ np.linalg.pinv(sqrt_cur_gram_mat) @ sqrt_target_gram_mat
     cumsum_ds = [0] + list(np.cumsum(ds))
     return [stacked_Vs[:, s: e] for s, e in zip(cumsum_ds[:-1], cumsum_ds[1:])]
 

{groupmultiness-0.0.2 → groupmultiness-0.0.4}/GroupMultiNeSS.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GroupMultiNeSS
-Version: 0.0.2
+Version: 0.0.4
 Summary: GroupMultiNeSS package
 Author: Alexander Kagan
 Author-email: <amkagan@umich.edu>
@@ -34,11 +34,11 @@ Dynamic: summary
 
 # GroupMultiNeSS
 
-GroupMultiNeSS is a package for statistical modeling of multilayer networks. It implements multiple approaches allowing to extract shared, group, and individual latent structures from a collection of networks on a shared set of nodes. Specifically, it contains the implementation of fitting sampling procedures for the following models:
+GroupMultiNeSS is a package for statistical modeling of multilayer networks. It implements multiple approaches allowing to extract shared, group, and individual latent structures from a collection of networks on a shared set of nodes. Specifically, it contains the implementation of fitting and sampling procedures for the following models:
 - GroupMultiNeSS [Kagan et al. (2025)] - likelihood based approach with nuclear norm penalization, accounts for the additional group latent structure
 - MultiNeSS [[MacDonald et al. (2021)](https://arxiv.org/abs/2012.14409)] - likelihood based approach with nuclear norm penalization
 - MultiNeSS [[Tian et al. (2024)](https://arxiv.org/abs/2412.02151)] - likelihood based approach with pre-estimation of latent ranks via Shared Space Hunting algorithm
-- COSIE ([Arroyo et al.](https://arxiv.org/abs/1906.10026)) - spectral-based Multiple Adjacency Spectral Embedding algorithm
+- COSIE [[Arroyo et al. (2020)](https://arxiv.org/abs/1906.10026)] - spectral-based Multiple Adjacency Spectral Embedding algorithm
 
 ## Installation
 
@@ -81,7 +81,7 @@ print(group_multiness.make_final_error_report(S_true, Qs_true, Rs_true, Ps=Ps_tr
 
 MIT License
 
-Copyright (c) 2024 Alexander Kagan
+Copyright (c) 2025 Alexander Kagan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{groupmultiness-0.0.2 → groupmultiness-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GroupMultiNeSS
-Version: 0.0.2
+Version: 0.0.4
 Summary: GroupMultiNeSS package
 Author: Alexander Kagan
 Author-email: <amkagan@umich.edu>
@@ -34,11 +34,11 @@ Dynamic: summary
 
 # GroupMultiNeSS
 
-GroupMultiNeSS is a package for statistical modeling of multilayer networks. It implements multiple approaches allowing to extract shared, group, and individual latent structures from a collection of networks on a shared set of nodes. Specifically, it contains the implementation of fitting sampling procedures for the following models:
+GroupMultiNeSS is a package for statistical modeling of multilayer networks. It implements multiple approaches allowing to extract shared, group, and individual latent structures from a collection of networks on a shared set of nodes. Specifically, it contains the implementation of fitting and sampling procedures for the following models:
 - GroupMultiNeSS [Kagan et al. (2025)] - likelihood based approach with nuclear norm penalization, accounts for the additional group latent structure
 - MultiNeSS [[MacDonald et al. (2021)](https://arxiv.org/abs/2012.14409)] - likelihood based approach with nuclear norm penalization
 - MultiNeSS [[Tian et al. (2024)](https://arxiv.org/abs/2412.02151)] - likelihood based approach with pre-estimation of latent ranks via Shared Space Hunting algorithm
-- COSIE ([Arroyo et al.](https://arxiv.org/abs/1906.10026)) - spectral-based Multiple Adjacency Spectral Embedding algorithm
+- COSIE [[Arroyo et al. (2020)](https://arxiv.org/abs/1906.10026)] - spectral-based Multiple Adjacency Spectral Embedding algorithm
 
 ## Installation
 
@@ -81,7 +81,7 @@ print(group_multiness.make_final_error_report(S_true, Qs_true, Rs_true, Ps=Ps_tr
 
 MIT License
 
-Copyright (c) 2024 Alexander Kagan
+Copyright (c) 2025 Alexander Kagan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{groupmultiness-0.0.2 → groupmultiness-0.0.4}/README.md

@@ -1,10 +1,10 @@
 # GroupMultiNeSS
 
-GroupMultiNeSS is a package for statistical modeling of multilayer networks. It implements multiple approaches allowing to extract shared, group, and individual latent structures from a collection of networks on a shared set of nodes. Specifically, it contains the implementation of fitting sampling procedures for the following models:
+GroupMultiNeSS is a package for statistical modeling of multilayer networks. It implements multiple approaches allowing to extract shared, group, and individual latent structures from a collection of networks on a shared set of nodes. Specifically, it contains the implementation of fitting and sampling procedures for the following models:
 - GroupMultiNeSS [Kagan et al. (2025)] - likelihood based approach with nuclear norm penalization, accounts for the additional group latent structure
 - MultiNeSS [[MacDonald et al. (2021)](https://arxiv.org/abs/2012.14409)] - likelihood based approach with nuclear norm penalization
 - MultiNeSS [[Tian et al. (2024)](https://arxiv.org/abs/2412.02151)] - likelihood based approach with pre-estimation of latent ranks via Shared Space Hunting algorithm
-- COSIE ([Arroyo et al.](https://arxiv.org/abs/1906.10026)) - spectral-based Multiple Adjacency Spectral Embedding algorithm
+- COSIE [[Arroyo et al. (2020)](https://arxiv.org/abs/1906.10026)] - spectral-based Multiple Adjacency Spectral Embedding algorithm
 
 ## Installation
 
@@ -47,7 +47,7 @@ print(group_multiness.make_final_error_report(S_true, Qs_true, Rs_true, Ps=Ps_tr
 
 MIT License
 
-Copyright (c) 2024 Alexander Kagan
+Copyright (c) 2025 Alexander Kagan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{groupmultiness-0.0.2 → groupmultiness-0.0.4}/setup.py

@@ -3,7 +3,7 @@ from pathlib import Path
 this_directory = Path(__file__).parent
 LONG_DESCRIPTION = (this_directory / "README.md").read_text()
 
-VERSION = '0.0.2'
+VERSION = '0.0.4'
 DESCRIPTION = 'GroupMultiNeSS package'
 
 setup(