dspin 1.3.5__tar.gz → 1.4.2__tar.gz

{dspin-1.3.5/dspin.egg-info → dspin-1.4.2}/PKG-INFO

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

{dspin-1.3.5 → dspin-1.4.2}/README.md

@@ -18,6 +18,8 @@ The MATLAB code can be downloaded from the folder "DSPIN_matlab", and directly e
 
 ## Demos
 
+A tutorial intended for an invited book chapter is available at [bioRxiv](https://www.biorxiv.org/content/10.1101/2025.07.28.667326).
+
 Two demos of D-SPIN are available on Google Colab. 
 
 The first demo reconstructs the regulatory network of simulated hematopoietic stem cell (HSC) differentiation network with perturbations using the BEELINE framework (Pratapa, Aditya, et al. Nature methods, 2020). 
@@ -170,6 +172,8 @@ model_gene.program_regulator_discovery(
 
 1. Jiang, Jialong, et al. "D-SPIN constructs gene regulatory network models from multiplexed scRNA-seq data revealing organizing principles of cellular perturbation response." bioRxiv (2023).
 
-2. Pratapa, Aditya, et al. "Benchmarking algorithms for gene regulatory network inference from single-cell transcriptomic data." Nature methods 17.2 (2020): 147-154.
+2. Jiang, Jialong, and Thomson, Matt. "A guide to D-SPIN: constructing regulatory network models from single-cell RNA-seq perturbation data." bioRxiv (2025).
+
+3. Pratapa, Aditya, et al. "Benchmarking algorithms for gene regulatory network inference from single-cell transcriptomic data." Nature methods 17.2 (2020): 147-154.
 
-3. Cui, Ang, et al. "Dictionary of immune responses to cytokines at single-cell resolution." Nature 625.7994 (2024): 377-384.
+4. Cui, Ang, et al. "Dictionary of immune responses to cytokines at single-cell resolution." Nature 625.7994 (2024): 377-384.

dspin-1.4.2/dspin/__init__.py

@@ -0,0 +1,21 @@
+
+from . import annotate
+from . import compute
+from . import plot
+from . import dspin
+from importlib.metadata import version 
+
+# Import main classes for easy access
+from .dspin import DSPIN, GeneDSPIN, ProgramDSPIN, AbstractDSPIN
+
+__all__ = [
+    'DSPIN',
+    'GeneDSPIN', 
+    'ProgramDSPIN',
+    'AbstractDSPIN',
+    'annotate',
+    'compute',
+    'plot'
+]
+
+__version__ = version("DSPIN")

{dspin-1.3.5 → dspin-1.4.2}/dspin/compute.py

@@ -232,15 +232,16 @@ def onmf(X: np.array, rank: int, max_iter: int = 500) -> Tuple[np.array, np.arra
         coef_S = AtX / S.dot(AtX.T).dot(S)
         S = np.nan_to_num(S * coef_S) #, posinf=1e5)
 
-        pbar.update(1)
+        # pbar.update(1)
 
         # Calculate the reconstruction error every 10 iterations and update the
         # progress bar
-        if itr % 10 == 0:
+        if itr % 20 == 0:
             error = np.linalg.norm(X - np.dot(A, S), 'fro')
             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.update(20)
 
     pbar.close()
 
@@ -278,6 +279,8 @@ def compute_onmf(seed: int,
     """
     # Generate a random seed
     np.random.seed(seed)
+
+    tqdm._instances.clear()
     # Factorized Matrices
     H, W = onmf(gene_matrix, num_spin, max_iter)
 
@@ -608,7 +611,7 @@ def para_moments(j_mat: np.ndarray,
             spins[s] = (tmp % 3) - 1
             tmp //= 3
 
-        # Energy: E = −h·s − ½ sᵀJs
+        # Energy: E = −h·s − s'Js / 2
         energy: float = 0.0
         for ii in range(num_spin):
             energy -= h_vec[ii] * spins[ii]
@@ -796,6 +799,28 @@ def samp_moments(j_mat: np.ndarray,
     return corr_para, mean_para
 
 
+def _gradient_one_round(kk: int,
+                        cur_j: np.ndarray,
+                        cur_h: np.ndarray,
+                        raw_data_k,
+                        method: str,
+                        train_dat: Dict[str, Any]):
+    """Helper that compute gradient for a single round."""
+    if method == 'pseudo_likelihood':
+        j_grad, h_grad = pseudol_gradient(cur_j, cur_h[:, kk:kk + 1], raw_data_k, directed=train_dat['directed'])
+        h_grad = h_grad.flatten()
+    else:
+        if method == 'maximum_likelihood':
+            corr_para, mean_para = para_moments(cur_j, cur_h[:, kk])
+        elif method == 'mcmc_maximum_likelihood':
+            corr_para, mean_para = samp_moments(
+                    cur_j, cur_h[:, kk], train_dat['mcmc_samplingsz'], train_dat['mcmc_samplingmix'], train_dat['mcmc_samplegap'])
+        j_grad  = corr_para - raw_data_k[0]
+        h_grad  = mean_para  - raw_data_k[1].flatten()
+
+    return kk, j_grad, h_grad
+
+
 def compute_gradient(cur_j: np.ndarray,
                             cur_h: np.ndarray,
                             raw_data: List[Tuple[np.ndarray, np.ndarray]],
@@ -828,49 +853,32 @@ def compute_gradient(cur_j: np.ndarray,
     rec_jgrad = np.zeros((num_spin, num_spin, num_round))
     rec_hgrad = np.zeros((num_spin, num_round))
 
-    for kk in range(num_round):
-        # Computing gradients using the specified method.
-        if method == 'pseudo_likelihood':
+    if method == 'pseudo_likelihood':
+         for kk in range(num_round):
+            # Computing gradients using the specified method.
             j_grad, h_grad = pseudol_gradient(
                 cur_j, cur_h[:, kk: kk + 1], raw_data[kk], directed=train_dat['directed'])
             h_grad = h_grad.flatten()
-        else:
-            # Distinguishing between other methods and computing gradients
-            # accordingly
-            if method == 'maximum_likelihood':
-                corr_para, mean_para = para_moments(cur_j, cur_h[:, kk])
-            elif method == 'mcmc_maximum_likelihood':
-                corr_para, mean_para = samp_moments(
-                    cur_j, cur_h[:, kk], train_dat['mcmc_samplingsz'], train_dat['mcmc_samplingmix'], train_dat['mcmc_samplegap'])
-            j_grad = corr_para - raw_data[kk][0]
-            h_grad = mean_para - raw_data[kk][1].flatten()
-
-        rec_jgrad[:, :, kk] = j_grad
-        rec_hgrad[:, kk] = h_grad
-
-    return rec_jgrad, rec_hgrad
 
-
-def _gradient_one_round(kk: int,
-                        cur_j: np.ndarray,
-                        cur_h: np.ndarray,
-                        raw_data_k,
-                        method: str,
-                        train_dat: Dict[str, Any]):
-    """Helper that compute gradient for a single round."""
-    if method == 'pseudo_likelihood':
-        j_grad, h_grad = pseudol_gradient(cur_j, cur_h[:, kk:kk + 1], raw_data_k, directed=train_dat['directed'])
-        h_grad = h_grad.flatten()
+            rec_jgrad[:, :, kk] = j_grad
+            rec_hgrad[:, kk] = h_grad
     else:
-        if method == 'maximum_likelihood':
-            corr_para, mean_para = para_moments(cur_j, cur_h[:, kk])
-        elif method == 'mcmc_maximum_likelihood':
-            corr_para, mean_para = samp_moments(
-                    cur_j, cur_h[:, kk], train_dat['mcmc_samplingsz'], train_dat['mcmc_samplingmix'], train_dat['mcmc_samplegap'])
-        j_grad  = corr_para - raw_data_k[0]
-        h_grad  = mean_para  - raw_data_k[1].flatten()
-
-    return kk, j_grad, h_grad
+        n_jobs = train_dat.get('max_workers', min(num_round, os.cpu_count())) 
+        chunk = train_dat.get('chunk_size', 1)          # rounds per task
+        backend = 'loky'                                # process‑based
+
+        # print(f'Processing with {n_jobs} workers...')
+        with parallel_backend(backend, n_jobs=n_jobs):
+            results = Parallel(batch_size=chunk)(
+                delayed(_gradient_one_round)(kk, cur_j, cur_h, raw_data[kk], method, train_dat)
+                for kk in range(num_round)
+            )
+
+        for kk, j_grad, h_grad in results:
+            rec_jgrad[:, :, kk] = j_grad
+            rec_hgrad[:, kk] = h_grad
+        
+    return rec_jgrad, rec_hgrad
 
 
 def compute_gradient_para(cur_j: np.ndarray,
@@ -990,10 +998,13 @@ def apply_regularization(rec_jgrad: np.ndarray,
     
     if 'lambda_l2_j_prior_mask' in train_dat:
         rec_jgrad += train_dat['lambda_l2_j_prior_mask'] * (cur_j * (train_dat['j_prior_mask'] == 0))[:, :, np.newaxis]
+
+    if 'lambda_l1_j_prior_mask' in train_dat:
+        rec_jgrad += train_dat['lambda_l1_j_prior_mask'] * ((cur_j * (train_dat['j_prior_mask'] == 0))[:, :, np.newaxis] / 1e-3).clip(-1, 1)
     
     if print_regu:  
         print('Regularization parameters')
-        all_regu_list = ['lambda_l1_j', 'lambda_l1_h', 'lambda_l2_j', 'lambda_l2_h', 'lambda_l2_j_prior', 'lambda_l2_j_prior_mask', 'lambda_l2_h_rela_prior', 'lambda_l1_h_rela', 'lambda_l2_h_rela']
+        all_regu_list = ['lambda_l1_j', 'lambda_l1_h', 'lambda_l2_j', 'lambda_l2_h', 'lambda_l2_j_prior', 'lambda_l2_j_prior_mask', 'lambda_l2_h_rela_prior', 'lambda_l1_h_rela', 'lambda_l2_h_rela', 'lambda_l1_j_prior_mask']
         all_values = [train_dat.get(key, 0) for key in all_regu_list]
         for key, value in zip(all_regu_list, all_values):
             if value > 0:
@@ -1153,7 +1164,6 @@ def learn_network_adam(raw_data: Any,
         if (counter > backtrack_gap) and (rec_jgrad_sum_norm[counter - 1] > 1.5 * rec_jgrad_sum_norm[counter - 1 - backtrack_gap]):
             if_backtrack = True
             
-
         if (counter > 2 * backtrack_gap) and (counter % backtrack_gap == 0):
 
             est_cur_grad = rec_jgrad_sum_norm[counter - 1 - backtrack_gap: counter - 1].mean()
@@ -1162,7 +1172,6 @@ def learn_network_adam(raw_data: Any,
             if est_cur_grad > 1.05 * est_prev_grad:
                 if_backtrack = True
 
-
         if if_backtrack:
             print('Backtracking at epoch %d' % counter)
             backtrack_counter += 1
@@ -1180,8 +1189,7 @@ def learn_network_adam(raw_data: Any,
 
     pbar.close()
 
-    # Retrieve parameters corresponding to the minimum gradient norm found
-    # during training
+    # Retrieve parameters corresponding to the minimum gradient norm found during training
     trace_epoch = 50 + num_epoch - counter
     pos = num_epoch - trace_epoch + np.argmin(rec_jgrad_sum_norm[- trace_epoch: ])
     # print(pos)
@@ -1221,16 +1229,14 @@ def learn_program_regulators(gene_states: List[np.ndarray],
     num_round = len(gene_states)
 
     num_epoch, stepsz, rec_gap = (
-        train_dat.get(
-            key, None) for key in [
+        train_dat.get(key, None) for key in [
             "num_epoch", "stepsz", "rec_gap"])
     list_step = np.arange(num_epoch, 0, - rec_gap)[::-1]
 
     save_path = train_dat.get('save_path', None)
 
     backtrack_gap, backtrack_tol = (
-        train_dat.get(
-            key, None) for key in [
+        train_dat.get(key, None) for key in [
             "backtrack_gap", "backtrack_tol"])
 
     lambda_l1_j, lambda_l2_j = (train_dat.get(key, 0) for key in ["lambda_l1_j", "lambda_l2_j"])
@@ -1246,6 +1252,10 @@ def learn_program_regulators(gene_states: List[np.ndarray],
     samp_weight = samp_weight / np.sum(samp_weight)
     
     # Preallocate gradient norm recording (optional)
+    rec_interaction_all = np.zeros((num_epoch, num_gene, num_program))
+    rec_selfj_all = np.zeros((num_epoch, num_program))
+    rec_selfh_all = np.zeros((num_epoch, num_program))
+    
     rec_grad = np.zeros(num_epoch)
 
     m_interaction, v_interaction = np.zeros_like(cur_interaction), np.zeros_like(cur_interaction)
@@ -1265,9 +1275,14 @@ def learn_program_regulators(gene_states: List[np.ndarray],
     rec_interaction_grad = np.zeros((num_round, num_gene, num_program))
     rec_selfj_grad = np.zeros((num_round, num_program))
     rec_selfh_grad = np.zeros((num_round, num_program))
-    
+
+    log_adam_grad = {name: deque(maxlen=backtrack_gap)
+                     for name in ["m_interaction", "v_interaction", "m_selfj", "v_selfj", "m_selfh", "v_selfh"]}
+
+    tqdm._instances.clear()
     pbar = tqdm(total=num_epoch)
     counter = 1
+    backtrack_counter = 0
 
     while counter <= num_epoch:
 
@@ -1320,15 +1335,52 @@ def learn_program_regulators(gene_states: List[np.ndarray],
         update_val, m_selfh, v_selfh = update_adam(selfh_grad, m_selfh, v_selfh, counter, stepsz)
         cur_selfh = cur_selfh - update_val
         
+        rec_interaction_all[counter - 1, :, :] = cur_interaction
+        rec_selfj_all[counter - 1, :] = cur_selfj
+        rec_selfh_all[counter - 1, :] = cur_selfh
+        
+        for name, value in zip(["m_interaction", "v_interaction", "m_selfj", "v_selfj", "m_selfh", "v_selfh"], [m_interaction, v_interaction, m_selfj, v_selfj, m_selfh, v_selfh]):
+            log_adam_grad[name].append(value)
+        
         # Record gradient norm (optional)
         rec_grad[counter - 1] = np.linalg.norm(interaction_grad)
         
         if counter in list_step:
             pbar.update(rec_gap)
-            pbar.set_postfix({"Network Gradient": f"{rec_grad[counter - 1]:.4f}"})
+            pbar.set_postfix({"Network Gradient": f"{rec_grad[counter - 1]:.6f}"})
+
+        if_backtrack = False
+        if (counter > backtrack_gap) and (rec_grad[counter - 1] > 1.5 * rec_grad[counter - 1 - backtrack_gap]):
+            if_backtrack = True
+            
+        if (counter > 2 * backtrack_gap) and (counter % backtrack_gap == 0):
+            est_cur_grad = rec_grad[counter - 1 - backtrack_gap: counter - 1].mean()
+            est_prev_grad = rec_grad[counter - 1 - 2 * backtrack_gap: counter - 1 - backtrack_gap].mean()
+            
+            if est_cur_grad > 1.05 * est_prev_grad:
+                if_backtrack = True
 
-        counter += 1
+        if if_backtrack:
+            print('Backtracking at epoch %d' % counter)
+            backtrack_counter += 1
+            m_interaction, v_interaction, m_selfj, v_selfj, m_selfh, v_selfh = [log_adam_grad[key][0] for key in ["m_interaction", "v_interaction", "m_selfj", "v_selfj", "m_selfh", "v_selfh"]]
+            counter = counter - backtrack_gap
+            stepsz = stepsz / 4
+            if backtrack_counter > backtrack_tol:
+                print(f'Backtracking more than {backtrack_tol} times, stop training.')
+                break
+        else:   
+            counter += 1
     
+    pbar.close()
+
+    # Retrieve parameters corresponding to the minimum gradient norm found during training
+    trace_epoch = 50 + num_epoch - counter
+    pos = num_epoch - trace_epoch + np.argmin(rec_grad[- trace_epoch: ])
+    cur_interaction = rec_interaction_all[pos, :, :]
+    cur_selfj = rec_selfj_all[pos, :]
+    cur_selfh = rec_selfh_all[pos, :]
+
     return cur_interaction, cur_selfj, cur_selfh
 
 

{dspin-1.3.5 → dspin-1.4.2}/dspin/dspin.py

@@ -35,6 +35,9 @@ import warnings
 import itertools
 from typing import List, Dict, Optional, Tuple, Union
 from scipy.stats import skew
+import leidenalg as la
+import igraph as ig
+import matplotlib as mpl
 
 
 class AbstractDSPIN(ABC):
@@ -106,6 +109,14 @@ class AbstractDSPIN(ABC):
     @property
     def sample_list(self):
         return self._samp_list
+    
+    @property
+    def name_list(self):
+        return self._name_list
+
+    @property
+    def name_list_short(self):
+        return self._name_list_short
 
     @program_representation_raw.setter
     def program_representation_raw(self, value):
@@ -131,6 +142,14 @@ class AbstractDSPIN(ABC):
     def sample_list(self, value):
         self._samp_list = value
 
+    @name_list.setter
+    def name_list(self, value):
+        self._name_list = value
+
+    @name_list_short.setter
+    def name_list_short(self, value):
+        self._name_list_short = value
+
     def discretize(self, 
                    clip_percentile: float = 100,
                    num_init: int = 10) -> None:
@@ -201,13 +220,13 @@ class AbstractDSPIN(ABC):
         num_spin = self.num_spin
         raw_data = self._raw_data
 
-        if self.example_list is not None:
-            example_list_ind = [list(self._samp_list).index(samp)
-                                for samp in self.example_list]
-            self._samp_list = self._samp_list[example_list_ind]
-            raw_data = raw_data[example_list_ind]
+        if self.sample_list_ordered is not None:
+            sample_list_ordered_ind = [list(self._samp_list).index(samp)
+                                for samp in self.sample_list_ordered]
+            self._samp_list = self._samp_list[sample_list_ordered_ind]
+            raw_data = raw_data[sample_list_ordered_ind]
             self._raw_data = raw_data
-            print("Using a subset of {} samples for network inference.".format(len(self._samp_list)))
+            print("Using a ordered subset of {} samples for network inference.".format(len(self._samp_list)))
 
         num_sample = len(raw_data)
         params = {'num_epoch': 400,
@@ -241,7 +260,11 @@ class AbstractDSPIN(ABC):
                           method: str = 'auto',
                           directed: bool = False,
                           params: dict = None,
-                          example_list: List[str] = None,
+                          sample_list_ordered: List[str] = None,
+                          prior_network: np.ndarray = None,
+                          perturb_matrix: np.ndarray = None,
+                          if_control_key: str = 'if_control',
+                          batch_key: str = 'batch',
                           run_with_matlab: bool = False) -> None:
         """
         Perform network inference using a specified method and parameters.
@@ -256,8 +279,16 @@ class AbstractDSPIN(ABC):
             Whether to infer a directed network. Default is False.
         params : dict, optional
             Additional parameters for network inference. Default is None.
-        example_list : List[str], optional
-            List of example sample identifiers. Default is None.
+        sample_list_ordered : List[str], optional
+            List of ordered sample identifiers. Default is None.
+        prior_network : np.ndarray, optional
+            Binary matrix of preferred network connectivity from prior knowledge. Default is None.
+        perturb_matrix : np.ndarray, optional
+            Matrix of putative relative responses to control samples. Default is None.
+        if_control_key : str, optional
+            Column name in `adata.obs` indicating whether a sample is a control. Default is 'if_control'.
+        batch_key : str, optional
+            Column name in `adata.obs` specifying batch assignment for each sample. Default is 'batch'.
         run_with_matlab : bool, optional
             If True, prepares data for MATLAB execution instead of running inference in Python. Default is False.
         """
@@ -275,8 +306,8 @@ class AbstractDSPIN(ABC):
         if method == 'auto':           
             samp_list = np.unique(self.adata.obs[sample_id_key])
             num_sample = len(samp_list)
-            if example_list is not None:
-                num_sample = len(example_list)
+            if sample_list_ordered is not None:
+                num_sample = len(sample_list_ordered)
             if num_sample > 30:
                 method = 'pseudo_likelihood'
             else:
@@ -296,9 +327,32 @@ class AbstractDSPIN(ABC):
         else:
             self.raw_data_corr(sample_id_key)
 
-        self.example_list = example_list
+        self.sample_list_ordered = sample_list_ordered
 
         train_dat = self.default_params(method)
+
+        if prior_network is not None:
+            train_dat['j_prior_mask'] = prior_network
+            train_dat['lambda_l1_j_prior_mask'] = 0.01
+
+        if perturb_matrix is not None:
+            if if_control_key not in self.adata.obs.columns:
+                raise ValueError(f"Column '{if_control_key}' not found in adata.obs.")
+            if batch_key not in self.adata.obs.columns:
+                raise ValueError(f"Column '{batch_key}' not found in adata.obs.")
+
+            sample_list = self._samp_list
+            sample_to_control = self.adata.obs.groupby(sample_id_key, observed=False)[if_control_key].first().to_dict()
+            sample_to_batch = self.adata.obs.groupby(sample_id_key, observed=False)[batch_key].first().to_dict()
+
+            if_control = np.array([sample_to_control[sample] for sample in sample_list])
+            batch_index = np.array([sample_to_batch[sample] for sample in sample_list])
+
+            train_dat['perturb_matrix'] = perturb_matrix
+            train_dat['if_control'] = if_control
+            train_dat['batch_index'] = batch_index
+            train_dat['lambda_l2_h_rela_prior'] = 0.5
+
         train_dat['directed'] = directed
         if params is not None:
             train_dat.update(params)
@@ -390,9 +444,10 @@ class GeneDSPIN(AbstractDSPIN):
             cur_gene = self._onmf_rep_ori[:, ii]
             gene_skew[ii] = skew(cur_gene, bias=False)
 
-        if gene_skew.mean() > 2:
+        print(f'Skewness of the gene expression: {gene_skew.mean().round(3)}')
+
+        if gene_skew.mean() >= 1.5:
             default_clip = 95
-            print("Input gene expression seem to be heavy-tailed. Using 95 percentile for clipping before discretization.")
         else:
             default_clip = 100
 
@@ -400,13 +455,20 @@ class GeneDSPIN(AbstractDSPIN):
                    'clip_percentile': default_clip,
                    'num_init': 10}
         dparams.update(discretize_params)
-        
+
+        self.name_list = self.adata.var_names.tolist()
+        self.name_list_short = self.adata.var_names.tolist()
+
         if dparams['use_default_discretize']:
+
+            if dparams['clip_percentile'] < 100:
+                print(f"Input gene expression seem to be heavy-tailed. Using {dparams['clip_percentile']} percentile for clipping before discretization.")
+
             self.discretize(clip_percentile=dparams['clip_percentile'], 
                             num_init=dparams['num_init'])
 
     def program_regulator_discovery(self, 
-                                    program_representation_raw: np.ndarray, 
+                                    program_representation: np.ndarray, 
                                     sample_id_key: str = 'sample_id',
                                     params: dict = None):
         """
@@ -414,7 +476,7 @@ class GeneDSPIN(AbstractDSPIN):
 
         Parameters
         ----------
-        program_representation_raw : np.ndarray
+        program_representation : np.ndarray
             The gene program representation.
         sample_id_key : str, optional
             Column name in `adata.obs` specifying sample identifiers. Default is 'sample_id'.
@@ -422,7 +484,7 @@ class GeneDSPIN(AbstractDSPIN):
             Additional parameters for regression. Default is None.
         """
 
-        program_states, samp_list = sample_states(self.adata.obs[sample_id_key], program_representation_raw)
+        program_states, samp_list = sample_states(self.adata.obs[sample_id_key], program_representation)
 
         gene_states, _ = sample_states(self.adata.obs[sample_id_key], self._onmf_rep_tri)
 
@@ -430,7 +492,9 @@ class GeneDSPIN(AbstractDSPIN):
             'num_epoch': 500,
             'stepsz': 0.01,
             'lambda_l1_interaction': 0.01,
-            'rec_gap': 10
+            'rec_gap': 10,
+            'backtrack_gap': 40,
+            'backtrack_tol': 5
         }
 
         if params is not None:
@@ -664,11 +728,11 @@ class ProgramDSPIN(AbstractDSPIN):
         self.prior_programs_ind = prior_program_ind
 
         num_onmf_components = onmf_parameters['num_onmf_components']
+
+        os.makedirs(self.save_path + 'onmf/', exist_ok=True)
         
         if mode == 'compute_summary' or mode == 'compute_only':
 
-            os.makedirs(self.save_path + 'onmf/', exist_ok=True)
-
             cur_gene_matrix = adata.X[:, prior_program_mask]
             cluster_label_raw = adata.obs[cluster_key].values
             cluster_label = pd.factorize(cluster_label_raw)[0]
@@ -709,10 +773,11 @@ class ProgramDSPIN(AbstractDSPIN):
             # Save the gene programs to a CSV file
             file_path = onmf_to_csv(onmf_summary.components_, adata.var_names, self.save_path + f'gene_programs_total_{num_spin}_onmf_{num_onmf_components}_prior_{len(prior_program_ind)}.csv', thres=0.01)
             print('Gene program information saved to {}'.format(file_path))
-            file_wpath = onmf_to_csv(onmf_summary.components_, adata.var_names, self.save_path + f'gene_programs_total_{num_spin}_onmf_{num_onmf_components}_prior_{len(prior_program_ind)}_weights.csv', thres=0.01, if_write_weights=True)
-            # print('Gene programs saved to {}'.format(file_path))
             self.gene_program_csv = file_path
 
+            file_wpath = onmf_to_csv(onmf_summary.components_, adata.var_names, self.save_path + f'gene_programs_total_{num_spin}_onmf_{num_onmf_components}_prior_{len(prior_program_ind)}_weights.csv', thres=0.01, if_write_weights=True)
+            # print('Gene programs saved to {}'.format(file_path))
+            
             gene_matrix = self.adata.X
             if issparse(gene_matrix):
                 gene_matrix = np.asarray(gene_matrix.toarray()).astype(np.float64)
@@ -727,6 +792,20 @@ class ProgramDSPIN(AbstractDSPIN):
             self.discretize(clip_percentile=dparams['clip_percentile'],
                             num_init=dparams['num_init'])
 
+        num_display_gene = 5
+        gene_pd = pd.read_csv(self.gene_program_csv, index_col=None)
+        
+        top_gene_list = [gene_pd.iloc[:, ii].tolist()[:num_display_gene] for ii in range(num_spin)]
+        # remove nan
+        top_gene_list_filtered = []
+        for sub_list in top_gene_list:
+            sub_list_filtered = [gene for gene in sub_list if str(gene) != 'nan']
+            top_gene_list_filtered.append(sub_list_filtered)
+
+        program_names = [f'P{ii}-' + ','.join(top_gene_list_filtered[ii]) for ii in range(num_spin)]
+        self.name_list = program_names
+        self.name_list_short = [name.split('-')[0] for name in program_names]
+
 
 class DSPIN(object):
     """