dspin 1.3.0__tar.gz → 1.3.2__tar.gz

{dspin-1.3.0/dspin.egg-info → dspin-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dspin
-Version: 1.3.0
+Version: 1.3.2
 Summary: Regulatory network models from single-cell perturbation profiling
 Home-page: https://github.com/JialongJiang/DSPIN
 Author: Jialong Jiang

{dspin-1.3.0 → dspin-1.3.2}/dspin/compute.py

@@ -76,7 +76,8 @@ import networkx as nx
 
 def summary_components(all_components: np.array,
                        num_spin: int,
-                       summary_method: str = 'kmeans') -> List[np.array]:
+                       summary_method: str = 'kmeans',
+                       figure_folder: str=None) -> List[np.array]:
     """
     Summarize components using a clustering algorithm.
 
@@ -88,6 +89,8 @@ def summary_components(all_components: np.array,
         The number of clusters.
     summary_method : str, optional
         The method used for summarizing the components. Options are 'kmeans' or 'leiden'. Default is 'kmeans'.
+    figure_folder : str, optional
+        Folder in which to save the figure.
 
     Returns
     -------
@@ -99,7 +102,12 @@ def summary_components(all_components: np.array,
     if summary_method == 'kmeans':
         # Fit KMeans clustering to the components and to their transposed version.
         kmeans = KMeans(n_clusters=num_spin, random_state=0, n_init=50).fit(all_components)
-        kmeans_gene = KMeans(n_clusters=2 * num_spin, random_state=0, n_init=10).fit(all_components.T)
+
+        # take the genes with larger weights for display only
+        gene_weight = np.sum(all_components ** 2, axis=0) ** 0.5
+        gene_sele_filt = gene_weight > np.mean(gene_weight)
+        all_components_sub = all_components[:, gene_sele_filt]
+        kmeans_gene = KMeans(n_clusters=2 * num_spin, random_state=0, n_init=10).fit(all_components_sub.T)
 
         # Initialize an array to store the average component for each cluster.
         components_kmeans = np.zeros((num_spin, num_gene))
@@ -115,6 +123,24 @@ def summary_components(all_components: np.array,
         for ii in range(num_spin):
             # Determine gene cluster assignments based on the maximum component values.
             gene_groups_ind.append(np.argmax(components_kmeans, axis=0) == ii)
+
+        
+
+        sc.set_figure_params(figsize=(8, 4))
+
+        plt.subplot(1, 2, 1)
+        gene_order = np.argsort(kmeans_gene.labels_)
+        comp_order = np.argsort(kmeans.labels_)
+        plt.imshow(all_components_sub[comp_order, :][:, gene_order], aspect='auto', cmap='Blues', vmax=np.max(all_components) / 10, interpolation='none')
+        plt.title('All components')
+
+        plt.subplot(1, 2, 2)
+        plt.imshow(components_kmeans[:, gene_sele_filt][:, gene_order], aspect='auto', cmap='Blues', vmax=np.max(components_kmeans) / 10, interpolation='none')
+        plt.title('Kmeans components')
+
+        if figure_folder is not None:
+            plt.savefig(figure_folder + 'onmf_decomposition_summary.png', dpi=300, bbox_inches='tight')
+            plt.close()
     
     elif summary_method == 'leiden':
 
@@ -144,8 +170,25 @@ def summary_components(all_components: np.array,
         diff = optimiser.optimise_partition(partition, n_iterations=- 1, is_membership_fixed=list(membership_fixed))
 
         gene_groups_ind = []
+        cluster_label_full = np.nan * np.ones(consensus.shape[0])
+
         for ii, part in enumerate(partition):
             gene_groups_ind.append(part)
+            cluster_label_full[part] = ii
+
+        gene_order = np.argsort(cluster_label_full)
+        gene_list_size = np.array([np.sum(cluster_label_full == ii) for ii in range(num_spin)])
+
+        plt.figure(figsize=[8, 8])
+        plt.imshow(consensus[gene_order][:, gene_order], cmap='Blues', vmin=0, vmax=np.percentile(consensus.flatten(), 98))
+        for ii in range(1, num_spin):
+            plt.axvline(np.sum(gene_list_size[:ii]) - 0.5, color='k')
+            plt.axhline(np.sum(gene_list_size[:ii]) - 0.5, color='k')
+        plt.grid()
+
+        if figure_folder is not None:
+            plt.savefig(figure_folder + 'onmf_decomposition_summary.png', dpi=300, bbox_inches='tight')
+            plt.close()
 
     return gene_groups_ind
 
@@ -194,7 +237,9 @@ def onmf(X: np.array, rank: int, max_iter: int = 500) -> Tuple[np.array, np.arra
         # progress bar
         if itr % 10 == 0:
             error = np.linalg.norm(X - np.dot(A, S), 'fro')
-            pbar.set_postfix({"Reconstruction Error": f"{error:.2f}"})
+            self_product = S.dot(S.T)
+            orthogonal_error = np.linalg.norm(self_product - np.diag(np.diag(self_product)), 'fro') / np.linalg.norm(S, 'fro')
+            pbar.set_postfix({"Reconstruction error": f"{error:.2f}", "Orthogonal error": f"{orthogonal_error:.4f}"})
 
     pbar.close()
 
@@ -245,7 +290,9 @@ def compute_onmf(seed: int,
     return nmf_model
 
 
-def onmf_discretize(onmf_rep_ori: np.array, fig_folder: str = None) -> np.array:
+def onmf_discretize(onmf_rep_ori: np.array, 
+                    num_init: int = 10,
+                    fig_folder: str = None) -> np.array:
     """
     Discretize the ONMF representation using KMeans clustering and visualize the sorted representations.
 
@@ -268,10 +315,11 @@ def onmf_discretize(onmf_rep_ori: np.array, fig_folder: str = None) -> np.array:
             21, num_spin))
 
     onmf_rep_tri = np.zeros(onmf_rep_ori.shape)
-    for ii in range(num_spin):
+    print('Processing gene or program expression levels...')
+    for ii in tqdm(range(num_spin)):
         # Perform KMeans clustering for each spin/component
-        km_fit = KMeans(n_clusters=3, n_init=10).fit(
-            onmf_rep_ori[:, ii].reshape(-1, 1))
+        km_fit = KMeans(n_clusters=3, n_init=num_init).fit(onmf_rep_ori[:, ii].reshape(-1, 1))
+
         onmf_rep_tri[:, ii] = (km_fit.labels_ == np.argsort(km_fit.cluster_centers_.reshape(-1))[0]) * \
             (-1) + (km_fit.labels_ == np.argsort(km_fit.cluster_centers_.reshape(-1))[2]) * 1
 
@@ -279,8 +327,7 @@ def onmf_discretize(onmf_rep_ori: np.array, fig_folder: str = None) -> np.array:
         if ii < 21:
             ax = plt.subplot(grid[ii])
             plt.plot(np.sort(onmf_rep_ori[:, ii]))
-            plt.plot(np.sort(km_fit.cluster_centers_[
-                     km_fit.labels_].reshape(-1)))
+            plt.plot(np.sort(km_fit.cluster_centers_[km_fit.labels_].reshape(-1)))
 
     # Save the visual representation
     if fig_folder is not None:
@@ -519,50 +566,7 @@ def para_moments(j_mat: np.array, h_vec: np.array) -> Tuple[np.array, np.array]:
     return corr_para, mean_para
 
 
-@numba.njit
-def np_apply_along_axis(func1d: Callable[[np.ndarray], float], 
-                        axis: int, 
-                        arr: np.ndarray) -> np.ndarray:
-    """
-    Applies a function along the specified axis.
-
-    Parameters
-    ----------
-    func1d : Callable[[np.ndarray], float]
-        A 1-D function to be applied.
-    axis : int
-        Axis along which the function should be applied.
-    arr : np.ndarray
-        Input array.
-
-    Returns
-    -------
-    np.ndarray
-        The result of applying func1d to arr along the specified axis.
-    """
-    assert arr.ndim == 2
-    assert axis in [0, 1]
-    result = np.empty(arr.shape[1]) if axis == 0 else np.empty(arr.shape[0])
-
-    for i in range(len(result)):
-        result[i] = func1d(arr[:, i]) if axis == 0 else func1d(arr[i, :])
-
-    return result
-
-
-@numba.njit
-def np_mean(array: np.array, axis: int) -> np.array:
-    """
-    Computes the arithmetic mean along the specified axis.
-
-    Parameters:
-    array (np.array): Input array.
-    axis (int): Axis along which the mean is computed. 1 is for row-wise, 0 is for column-wise.
-    """
-    return np_apply_along_axis(np.mean, axis, array)
-
-
-@numba.jit()
+@numba.njit(fastmath=True)
 def pseudol_gradient(cur_j: np.ndarray, 
                      cur_h: np.ndarray, 
                      cur_state: np.ndarray, 
@@ -587,37 +591,43 @@ def pseudol_gradient(cur_j: np.ndarray,
         The gradient of j.
         The gradient of h.
     """
-    num_spin = cur_j.shape[0]
+    num_spin, num_sample = cur_state.shape
+    sample_factor = 1.0 / num_sample     
 
-    cur_j_grad = np.zeros((num_spin, num_spin))
-    cur_h_grad = np.zeros((num_spin, 1))
-
-    # Filtering diagonal elements of cur_j matrix.
-    j_filt = cur_j.copy()
-    np.fill_diagonal(j_filt, 0)
-    effective_h = j_filt.dot(cur_state) + cur_h
+    diag_j = np.empty(num_spin, dtype=cur_j.dtype)
+    for ii in range(num_spin):
+        diag_j[ii] = cur_j[ii, ii]
 
+    j_no_diag = cur_j.copy()
     for ii in range(num_spin):
-        # Calculating gradients for each spin.
-        j_sub = cur_j[ii, ii]
-        h_sub = effective_h[ii, :]
+        j_no_diag[ii, ii] = 0.0
 
-        term1 = np.exp(j_sub + h_sub)
-        term2 = np.exp(j_sub - h_sub)
+    eff_h = j_no_diag @ cur_state + cur_h.reshape(num_spin, 1)  
 
-        # Compute gradients.
-        j_sub_grad = cur_state[ii, :] ** 2 - \
-            (term1 + term2) / (term1 + term2 + 1)
-        h_eff_grad = cur_state[ii, :] - (term1 - term2) / (term1 + term2 + 1)
+    exp_plus = np.empty_like(eff_h)
+    exp_minus = np.empty_like(eff_h)
+    denom = np.empty_like(eff_h)
 
-        j_off_sub_grad = h_eff_grad * cur_state
+    for ii in range(num_spin):
+        exp_plus[ii, :] = np.exp(diag_j[ii] + eff_h[ii, :])
+        exp_minus[ii, :] = np.exp(diag_j[ii] - eff_h[ii, :])
+        denom[ii, :] = exp_plus[ii, :] + exp_minus[ii, :] + 1.0
+
+    # Diagonal (self‑coupling) gradients 
+    term_diag = cur_state * cur_state - (exp_plus + exp_minus) / denom
+
+    # Off‑diagonal and field gradients 
+    h_eff_grad = cur_state - (exp_plus - exp_minus) / denom
+    cur_j_grad = (h_eff_grad @ cur_state.T) * sample_factor
+    for ii in range(num_spin):
+        cur_j_grad[ii, ii] = np.sum(term_diag[ii, :]) * sample_factor
 
-        cur_j_grad[ii, :] = np_mean(j_off_sub_grad, axis=1)
-        cur_j_grad[ii, ii] = np.mean(j_sub_grad)
-        cur_h_grad[ii] = np.mean(h_eff_grad)
+    cur_h_grad = np.zeros((num_spin, 1), dtype=cur_j.dtype)
+    for ii in range(num_spin):
+        cur_h_grad[ii, 0] = np.sum(h_eff_grad[ii, :]) * sample_factor
 
-        if not directed:
-            cur_j_grad = (cur_j_grad + cur_j_grad.T) / 2
+    if not directed:
+        cur_j_grad = 0.5 * (cur_j_grad + cur_j_grad.T)
 
     return - cur_j_grad, - cur_h_grad
 
@@ -927,6 +937,8 @@ def learn_network_adam(raw_data: Any,
         The trained h matrix.
         The training log.
     """
+    np.random.seed(train_dat['seed'])
+
     # Retrieve training parameters and data
     num_spin, num_round = train_dat['cur_h'].shape
     num_epoch, stepsz, rec_gap = (
@@ -936,10 +948,7 @@ def learn_network_adam(raw_data: Any,
     list_step = np.arange(num_epoch, 0, - rec_gap)[::-1]
     cur_j, cur_h = (train_dat.get(key, None) for key in ["cur_j", "cur_h"])
     save_path = train_dat.get('save_path', None)
-    backtrack_gap, backtrack_tol = (
-        train_dat.get(
-            key, None) for key in [
-            "backtrack_gap", "backtrack_tol"])
+    backtrack_gap, backtrack_tol = (train_dat.get(key, None) for key in ["backtrack_gap", "backtrack_tol"])
 
     # Initialize variables to store parameters, gradients, and other values
     # during training
@@ -985,15 +994,15 @@ def learn_network_adam(raw_data: Any,
 
         # Save training log and print progress
         if counter in list_step:
-            sio.savemat(save_path + 'train_log.mat',
-                        {'list_step': list_step,
-                         'rec_hvec_all': rec_hvec_all,
-                         'rec_jmat_all': rec_jmat_all,
-                         'rec_jgrad_sum_norm': rec_jgrad_sum_norm})
-            # print('Progress: %d, Network gradient: %f' % (
-            #     np.round(100 * counter / num_epoch, 2), rec_jgrad_sum_norm[counter - 1]))
+            if train_dat['save_log']:
+                sio.savemat(save_path + 'train_log.mat',
+                            {'list_step': list_step,
+                            'rec_hvec_all': rec_hvec_all,
+                            'rec_jmat_all': rec_jmat_all,
+                            'rec_jgrad_sum_norm': rec_jgrad_sum_norm})
+
             pbar.update(rec_gap)
-            pbar.set_postfix({"Network Gradient": f"{rec_jgrad_sum_norm[counter - 1]:.4f}"})
+            pbar.set_postfix({"Network Gradient": f"{rec_jgrad_sum_norm[counter - 1]:.6f}"})
 
         # Handle backtracking
         

{dspin-1.3.0 → dspin-1.3.2}/dspin/dspin.py

@@ -130,7 +130,9 @@ class AbstractDSPIN(ABC):
     def sample_list(self, value):
         self._samp_list = value
 
-    def discretize(self, clip_percentile: float = 100) -> None:
+    def discretize(self, 
+                   clip_percentile: float = 100,
+                   num_init: int = 10) -> None:
         """
         Discretizes the oNMF representation into three states (-1, 0, 1) using K-means clustering.
 
@@ -138,6 +140,8 @@ class AbstractDSPIN(ABC):
         ----------
         clip_percentile : float, optional
             Percentile at which to clip values before discretization (default is 100).
+        num_init : int, optional
+            Number of initializations for K-means clustering (default is 10).
         """
         onmf_rep_ori = self.program_representation_raw.copy()
         fig_folder = self.fig_folder
@@ -147,7 +151,7 @@ class AbstractDSPIN(ABC):
                 onmf_rep_ori[:, ii] = onmf_rep_ori[:, ii] / np.percentile(onmf_rep_ori[:, ii], clip_percentile)
             onmf_rep_ori = onmf_rep_ori.clip(0, 1)
 
-        onmf_rep_tri = onmf_discretize(onmf_rep_ori, fig_folder)
+        onmf_rep_tri = onmf_discretize(onmf_rep_ori, num_init, fig_folder)
         self._onmf_rep_tri = onmf_rep_tri
 
     def raw_data_corr(self, sample_id_key: str) -> None:
@@ -204,17 +208,19 @@ class AbstractDSPIN(ABC):
             self._raw_data = raw_data
 
         num_sample = len(raw_data)
-        params = {'num_epoch': 200,
+        params = {'num_epoch': 400,
                   'cur_j': np.zeros((num_spin, num_spin)),
                   'cur_h': np.zeros((num_spin, num_sample)),
                   'save_path': self.save_path, 
-                  'rec_gap': 10}
+                  'rec_gap': 10, 
+                  'seed': 0,
+                  'save_log': False}
         params.update({'lambda_l1_j': 0.01,
                        'lambda_l1_h': 0,
                        'lambda_l2_j': 0,
                        'lambda_l2_h': 0.005})
-        params.update({'backtrack_gap': 20,
-                       'backtrack_tol': 4})
+        params.update({'backtrack_gap': 40,
+                       'backtrack_tol': 5})
 
         if method == 'maximum_likelihood':
             params['stepsz'] = 0.2
@@ -350,7 +356,7 @@ class GeneDSPIN(AbstractDSPIN):
                  adata: ad.AnnData,
                  save_path: str,
                  num_spin: int,
-                 clip_percentile: float = 95):
+                 discretize_params: dict = {}):
         """
         Initialize the GeneDSPIN object.
 
@@ -362,6 +368,8 @@ class GeneDSPIN(AbstractDSPIN):
             Directory path where results will be saved.
         num_spin : int
             Number of spins used in inference.
+        use_default_discretize : bool, optional
+            Whether to use default discretization. Default is True. Otherwise the discretized data should be explicited setted in program_representation.
         clip_percentile : float, optional
             Percentile threshold for clipping values before discretization. Default is 95.
         """
@@ -374,7 +382,14 @@ class GeneDSPIN(AbstractDSPIN):
         else:
             self._onmf_rep_ori = adata.X
 
-        self.discretize(clip_percentile)
+        dparams = {'use_default_discretize': True,
+                   'clip_percentile': 95,
+                   'num_init': 10}
+        dparams.update(discretize_params)
+        
+        if dparams['use_default_discretize']:
+            self.discretize(clip_percentile=dparams['clip_percentile'], 
+                            num_init=dparams['num_init'])
 
     def program_regulator_discovery(self, 
                                     program_representation_raw: np.ndarray, 
@@ -439,10 +454,7 @@ class ProgramDSPIN(AbstractDSPIN):
     def __init__(self,
                  adata: ad.AnnData,
                  save_path: str,
-                 num_spin: int,
-                 num_onmf_components: int = None,
-                 prior_programs: List[List[str]] = None,
-                 num_repeat: int = 10):
+                 num_spin: int):
         """
         Initialize the ProgramDSPIN object.
 
@@ -454,12 +466,6 @@ class ProgramDSPIN(AbstractDSPIN):
             Directory path for saving results.
         num_spin : int
             Number of spins used in DSPIN.
-        num_onmf_components : int, optional
-            Number of oNMF components, default is None.
-        prior_programs : List[List[str]], optional
-            List of predefined gene programs.
-        num_repeat : int, optional
-            Number of repetitions for oNMF computation. Default is 10.
         """
         super().__init__(adata, save_path, num_spin)
 
@@ -469,8 +475,6 @@ class ProgramDSPIN(AbstractDSPIN):
         self._gene_matrix_large = None
         self._use_data_list = None
         self.gene_program_csv = None
-        self.prior_programs = None
-        self.preprogram_num = len(prior_programs) if prior_programs else 0
 
     @property
     def onmf_decomposition(self):
@@ -518,7 +522,7 @@ class ProgramDSPIN(AbstractDSPIN):
 
         all_components = rec_components.reshape(-1, np.sum(prior_programs_mask))
 
-        gene_group_ind = summary_components(all_components, num_onmf_components, summary_method=summary_method)
+        gene_group_ind = summary_components(all_components, num_onmf_components, summary_method=summary_method, figure_folder=self.fig_folder)
 
         # Mask the prior programs and add them to the gene group indices
         sub_mask_ind = np.where(prior_programs_mask)[0]
@@ -545,32 +549,28 @@ class ProgramDSPIN(AbstractDSPIN):
                                cluster_key: str = 'leiden',
                                mode: str = 'compute_summary',
                                prior_programs: List[List[str]] = None,
-                               params: dict = {}) -> None:
+                               clip_percentile: float = 100,
+                               params: dict = {},
+                               discretize_params: dict = {}) -> None:
         """
         Discover gene programs by performing oNMF decomposition on the annotated data.
 
         Parameters
         ----------
-        num_onmf_components : int, optional
-            Number of oNMF components. Default is None.
-        num_subsample : int, optional
-            Number of samples to use after subsampling. Default is 10000.
-        num_subsample_large : int, optional
-            Number of samples for large subsampling. Default is None.
         num_repeat : int, optional
             Number of times to repeat oNMF. Default is 10.
         seed : int, optional
             Random seed for reproducibility. Default is 0.
-        balance_obs : str, optional
-            Observation category to balance. Default is None.
-        balance_method : str, optional
-            Method used for balancing categories. Default is None.
-        max_sample_rate : float, optional
-            Maximum sampling rate. Default is 2.
+        cluster_key : str, optional
+            Key in `adata.obs` for clustering labels. Default is 'leiden'.
+        mode: str, optional
+            Mode of operation. Options: 'compute_summary', 'compute_only', 'summary_only'. Default is 'compute_summary'.
         prior_programs : List[List[str]], optional
             List of predefined gene programs. Default is None.
-        summary_method : str, optional
-            Method to summarize oNMF components. Default is 'kmeans'.
+        clip_percentile : float, optional
+            Percentile for clipping values before discretization. Default is 100.
+        params : dict, optional
+            Additional parameters for oNMF. Default is an empty dictionary.
         """
 
         if mode not in ['compute_summary', 'compute_only', 'summary_only']:
@@ -661,7 +661,12 @@ class ProgramDSPIN(AbstractDSPIN):
             self._onmf_rep_ori = onmf_summary.transform(
                 gene_matrix / self.matrix_std)
 
-            self.discretize()
+            dparams = {'clip_percentile': 100,
+                       'num_init': 10}
+            dparams.update(discretize_params)
+
+            self.discretize(clip_percentile=dparams['clip_percentile'],
+                            num_init=dparams['num_init'])
 
 
 class DSPIN(object):

{dspin-1.3.0 → dspin-1.3.2/dspin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dspin
-Version: 1.3.0
+Version: 1.3.2
 Summary: Regulatory network models from single-cell perturbation profiling
 Home-page: https://github.com/JialongJiang/DSPIN
 Author: Jialong Jiang

{dspin-1.3.0 → dspin-1.3.2}/setup.py

@@ -21,7 +21,7 @@ install_requires = [
 # ]
 
 # Managing your version (adjust accordingly)
-version = "1.3.0"  # You can manage versioning in a more sophisticated way if needed
+version = "1.3.2"  # You can manage versioning in a more sophisticated way if needed
 
 # Long description (usually a README file)
 readme = open("README_PyPI.md").read()  # Adjust the file name if necessary