dspin 1.3.1__tar.gz → 1.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dspin
-Version: 1.3.1
+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.1 → dspin-1.3.2}/dspin/compute.py

@@ -290,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.
 
@@ -313,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
 
@@ -324,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:
@@ -564,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, 
@@ -632,37 +591,43 @@ def pseudol_gradient(cur_j: np.ndarray,
         The gradient of j.
         The gradient of h.
     """
-    num_spin = cur_j.shape[0]
-
-    cur_j_grad = np.zeros((num_spin, num_spin))
-    cur_h_grad = np.zeros((num_spin, 1))
+    num_spin, num_sample = cur_state.shape
+    sample_factor = 1.0 / num_sample     
 
-    # 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
 
-        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)
+    # Diagonal (self‑coupling) gradients 
+    term_diag = cur_state * cur_state - (exp_plus + exp_minus) / denom
 
-        if not directed:
-            cur_j_grad = (cur_j_grad + cur_j_grad.T) / 2
+    # 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_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 = 0.5 * (cur_j_grad + cur_j_grad.T)
 
     return - cur_j_grad, - cur_h_grad
 
@@ -1029,13 +994,13 @@ 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]:.6f}"})
 

{dspin-1.3.1 → 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:
@@ -209,7 +213,8 @@ class AbstractDSPIN(ABC):
                   'cur_h': np.zeros((num_spin, num_sample)),
                   'save_path': self.save_path, 
                   'rec_gap': 10, 
-                  'seed': 0}
+                  'seed': 0,
+                  'save_log': False}
         params.update({'lambda_l1_j': 0.01,
                        'lambda_l1_h': 0,
                        'lambda_l2_j': 0,
@@ -351,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.
 
@@ -363,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.
         """
@@ -375,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, 
@@ -440,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.
 
@@ -455,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)
 
@@ -470,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):
@@ -546,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']:
@@ -662,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.1 → dspin-1.3.2/dspin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dspin
-Version: 1.3.1
+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.1 → dspin-1.3.2}/setup.py

@@ -21,7 +21,7 @@ install_requires = [
 # ]
 
 # Managing your version (adjust accordingly)
-version = "1.3.1"  # 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