dspin 1.1.2__tar.gz → 1.2.0__tar.gz

{dspin-1.1.2/dspin.egg-info → dspin-1.2.0}/PKG-INFO

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

{dspin-1.1.2 → dspin-1.2.0}/dspin/annotate.py

@@ -82,9 +82,9 @@ def automatic_david_annotation(data_folder, file_name, token_name, species='huma
 
     # Save results to Excel
     save_to_excel(data_folder, file_name,
-                  gene_id_map_reverse, num_list, full=False)
+                    gene_id_map_reverse, all_onmf_df.columns.tolist(), full=False)
     save_to_excel(data_folder, file_name,
-                  gene_id_map_reverse, num_list, full=True)
+                    gene_id_map_reverse, all_onmf_df.columns.tolist(), full=True)
 
 
 def make_user_prompt_with_score(genes, feature_df=[], direct=False, customized_prompt=None):
@@ -285,10 +285,10 @@ def setup_david_client(token_name):
 
     from suds.client import Client
 
-    url = 'https://david.ncifcrf.gov/webservice/services/DAVIDWebService?wsdl'
+    url = 'https://davidbioinformatics.nih.gov/webservice/services/DAVIDWebService?wsdl'
     client = Client(url)
     client.wsdl.services[0].setlocation(
-        'https://david.ncifcrf.gov/webservice/services/DAVIDWebService.DAVIDWebServiceHttpSoap11Endpoint/')
+        'https://davidbioinformatics.nih.gov/webservice/services/DAVIDWebService.DAVIDWebServiceHttpSoap11Endpoint/')
     client.service.authenticate(token_name)
     return client
 
@@ -359,7 +359,7 @@ def process_gene_lists(data_folder, file_name, all_onmf_df, gene_id_map, client)
     for i in range(num_lists):
         cur_gene_list = all_onmf_df.iloc[:, i].dropna()
         cur_gene_list = map_gene_ids(gene_id_map, cur_gene_list)
-        save_path = os.path.join(save_folder, f'list_{i}.csv')
+        save_path = os.path.join(save_folder, f'list_{all_onmf_df.columns[i]}.csv')
 
         input_ids = ','.join(cur_gene_list)
         id_type = 'ENSEMBL_GENE_ID'
@@ -370,7 +370,7 @@ def process_gene_lists(data_folder, file_name, all_onmf_df, gene_id_map, client)
         term_clustering_report = client.service.getTermClusterReport(
             overlap, initialSeed, finalSeed, linkage, kappa)
 
-        print(f'Gene list {i} ', end='\t')
+        print(f'Gene list {all_onmf_df.columns[i]} ', end='\t')
         # print(term_clustering_report)
         if term_clustering_report is None:
             raise Exception(
@@ -379,7 +379,7 @@ def process_gene_lists(data_folder, file_name, all_onmf_df, gene_id_map, client)
         parse_david_output(term_clustering_report, save_path)
 
 
-def save_to_excel(data_folder, file_name, gene_id_map_reverse, num_lists, full=True):
+def save_to_excel(data_folder, file_name, gene_id_map_reverse, list_name, full=True):
     """
     Save the parsed DAVID output to an Excel file, with an option to include full or filtered results.
 
@@ -387,7 +387,7 @@ def save_to_excel(data_folder, file_name, gene_id_map_reverse, num_lists, full=T
         data_folder (str): The folder where the data files are located.
         file_name (str): The name of the original CSV file containing gene data.
         gene_id_map_reverse (dict): A dictionary mapping ENSEMBL IDs to gene symbols.
-        num_lists (int): The number of gene lists processed.
+        list_name (list): A list of gene list names.
         full (bool): Whether to save the full results. If False, only results with Pvalue <= 0.05 are saved.
     """
 
@@ -433,8 +433,8 @@ def save_to_excel(data_folder, file_name, gene_id_map_reverse, num_lists, full=T
         '.csv', '_david_full.xlsx') if full else file_name.replace('.csv', '_david.xlsx')
 
     with pd.ExcelWriter(data_folder + xlsx_name) as writer:
-        for ii in range(num_lists):
-            cur_pd = pd.read_csv(save_folder + 'list_%d.csv' % ii, sep='\t', names=[
+        for lname in list_name:
+            cur_pd = pd.read_csv(save_folder + f'list_{lname}.csv', sep='\t', names=[
                                  'Category', 'Term', 'Count', '%', 'Pvalue', 'Genes', 'List Total', 'Pop Hits', 'Pop Total', 'Fold Enrichment', 'Bonferroni', 'Benjamini', 'FDR'])
             filt1 = cur_pd['Category'] == 'UP_SEQ_FEATURE'
             filt2 = cur_pd['Pvalue'].apply(filt_fun)
@@ -453,9 +453,10 @@ def save_to_excel(data_folder, file_name, gene_id_map_reverse, num_lists, full=T
                     cur_pd = pd.DataFrame(np.insert(
                         cur_pd.values, ind + kk, values=[" "] * len(cur_pd.columns), axis=0), columns=cur_pd.columns)
 
-            cur_pd.to_excel(writer, sheet_name='program_%d' % ii, index=False)
-            writer.sheets['program_%d' % ii].set_column(0, 0, 25)
-            writer.sheets['program_%d' % ii].set_column(1, 1, 50)
-            writer.sheets['program_%d' % ii].set_column(2, 2, 5)
-            writer.sheets['program_%d' % ii].set_column(3, 3, 5)
-            writer.sheets['program_%d' % ii].set_column(5, 5, 100)
+            sheet_name = lname
+            cur_pd.to_excel(writer, sheet_name=sheet_name, index=False)
+            writer.sheets[sheet_name].set_column(0, 0, 25)
+            writer.sheets[sheet_name].set_column(1, 1, 50)
+            writer.sheets[sheet_name].set_column(2, 2, 5)
+            writer.sheets[sheet_name].set_column(3, 3, 5)
+            writer.sheets[sheet_name].set_column(5, 5, 100)

{dspin-1.1.2 → dspin-1.2.0}/dspin/compute.py

@@ -17,7 +17,7 @@ import os
 from sklearn.cluster import KMeans
 import scipy.io as sio
 from tqdm import tqdm
-from typing import List
+from typing import List, Tuple
 
 
 def category_balance_number(
@@ -209,14 +209,14 @@ def onmf(X: np.array, rank: int, max_iter: int = 200) -> (np.array, np.array):
     return S.T, A
 
 
-def compute_onmf(seed: int, num_spin: int, gene_matrix_bin: np.array) -> NMF:
+def compute_onmf(seed: int, num_spin: int, gene_matrix: np.array) -> NMF:
     """
     Computes the ONMF model for the given gene matrix.
 
     Parameters:
     seed (int): Seed for Random Number Generation.
     num_spin (int): The number of desired components (clusters/spins).
-    gene_matrix_bin (np.array): Binary Matrix representing the gene expression data.
+    gene_matrix (np.array): Matrix representing the gene expression data. Typically the matrix should be normalized by library size and log-1 transfromed. Normalize each gene by its standard devaition is also recommended.
 
     Returns:
     NMF: The NMF model with computed components.
@@ -225,7 +225,7 @@ def compute_onmf(seed: int, num_spin: int, gene_matrix_bin: np.array) -> NMF:
     # Generate a random seed
     np.random.seed(seed)
     # Factorized Matrices
-    H, W = onmf(gene_matrix_bin, num_spin)
+    H, W = onmf(gene_matrix, num_spin)
 
     # Initialize the NMF model
     nmf_model = NMF(n_components=num_spin, random_state=seed)
@@ -338,6 +338,18 @@ def sample_corr_mean(samp_full: np.array,
     return raw_corr_data, samp_list
 
 
+def sample_states(samp_full: np.array, onmf_rep_tri: np.array) -> Tuple[np.array, np.array]:
+
+    samp_list = np.unique(samp_full)
+    state_list = np.zeros(len(samp_list), dtype=object)
+
+    for ii, cur_samp in enumerate(samp_list):
+        cur_filt = samp_full == cur_samp
+        cur_state = onmf_rep_tri[cur_filt, :]
+        state_list[ii] = cur_state.T
+
+    return state_list, samp_list
+
 def para_moments(j_mat: np.array, h_vec: np.array) -> (np.array, np.array):
     """
     Calculates the mean and correlation given j network and h vectors.
@@ -805,7 +817,7 @@ def learn_network_adam(raw_data, method, train_dat):
     # during training
     trace_epoch = 50 + num_epoch - counter
     pos = num_epoch - trace_epoch + np.argmin(rec_jgrad_sum_norm[- trace_epoch: ])
-    print(pos)
+    # print(pos)
     cur_h = rec_hvec_all[pos, :, :]
     cur_j = rec_jmat_all[pos, :, :]
 
@@ -815,6 +827,151 @@ def learn_network_adam(raw_data, method, train_dat):
     return cur_j, cur_h, train_log
 
 
+
+def learn_program_regulators(gene_states, program_states, train_dat):
+    """
+    Discover regulators for gene programs via regression.
+    
+    Parameters
+    ----------
+    gene_states : list of np.ndarray
+        Each element is a gene state array of shape (n_spin, T),
+        where T may vary across samples.
+    program_states : list of np.ndarray
+        Each element is a program state array of shape (n_target, T).
+    train_dat : dict
+        Dictionary of training parameters. Expected keys (with defaults):
+          - 'num_epoch': int, default 300
+          - 'stepsz': float, default 0.01
+          - 'decay': float, default 0.2 (not explicitly used here)
+          - 'interaction_l1': float, default 0.01
+          
+    Returns
+    -------
+    cur_interaction : np.ndarray
+        Learned interaction matrix of shape (n_spin, n_target).
+    cur_selfj : np.ndarray
+        Learned self-interaction (regulator-specific bias) of shape (n_target,).
+    cur_selfh : np.ndarray
+        Learned program activity bias of shape (n_target,).
+    """
+
+    num_gene = gene_states[0].shape[0]
+    num_program = program_states[0].shape[0]
+    num_round = len(gene_states)
+
+    num_epoch, stepsz, rec_gap = (
+        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 [
+            "backtrack_gap", "backtrack_tol"])
+
+    lambda_l1_j, lambda_l2_j = (train_dat.get(key, 0) for key in ["lambda_l1_j", "lambda_l2_j"])
+
+    # Initialize parameters (using zeros)
+    cur_interaction = np.zeros((num_gene, num_program))
+    cur_selfj = np.zeros(num_program)
+    cur_selfh = np.zeros(num_program)
+    
+    # Compute sample weights based on the number of states (columns) in each gene_states sample
+    state_sizes = np.array([state.shape[1] for state in gene_states])
+    samp_weight = np.sqrt(state_sizes)
+    samp_weight = samp_weight / np.sum(samp_weight)
+    
+    # Preallocate gradient norm recording (optional)
+    rec_grad = np.zeros(num_epoch)
+
+    m_interaction, v_interaction = np.zeros_like(cur_interaction), np.zeros_like(cur_interaction)
+    m_selfj, v_selfj = np.zeros_like(cur_selfj), np.zeros_like(cur_selfj)
+    m_selfh, v_selfh = np.zeros_like(cur_selfh), np.zeros_like(cur_selfh)
+    
+    # Create l1 regularization schedule
+    l1_base_start = 0.02
+    l1_base_end = 1e-3
+    
+    part1 = np.full((num_epoch // 4 + 1,), l1_base_start)
+    part2 = np.logspace(np.log10(l1_base_start), np.log10(l1_base_end), num=num_epoch // 2)
+    part3 = np.full((num_epoch // 4 + 1,), l1_base_end)
+    l1_base_array = np.concatenate([part1, part2, part3])[:num_epoch]
+    
+    # Preallocate arrays to collect per-sample gradients
+    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))
+    
+    pbar = tqdm(total=num_epoch)
+    counter = 1
+
+    while counter <= num_epoch:
+
+        l1_base = l1_base_array[counter - 1]
+        
+        for kk in range(num_round):
+            cur_state = gene_states[kk]         
+            cur_target = program_states[kk]   
+            
+            effective_h = cur_state.T @ cur_interaction  + cur_selfh.T
+            
+            # j_sub is the bias for regulators (broadcasted as row vector)
+            j_sub = cur_selfj.T  # shape: (n_target,)
+            
+            # Compute terms.
+            # We follow MATLAB: term1 = exp(j_sub + effective_h)' so that term1 becomes (n_target, T)
+            term1 = np.exp(j_sub + effective_h).T
+            term2 = np.exp(j_sub - effective_h).T
+            
+            # Compute gradients for the bias parameters per sample
+            j_sub_grad = cur_target**2 - (term1 + term2) / (term1 + term2 + 1)
+            h_eff_grad = cur_target - (term1 - term2) / (term1 + term2 + 1)
+            
+            # Gradient for interaction parameters
+            # cur_state: (n_spin, T), h_eff_grad.T: (T, n_target)
+            j_off_sub_grad = cur_state @ h_eff_grad.T  # shape: (n_spin, n_target)
+            
+            # Average over the T (state) dimension
+            rec_interaction_grad[kk] = j_off_sub_grad / cur_state.shape[1]
+            rec_selfj_grad[kk] = np.mean(j_sub_grad, axis=1)
+            rec_selfh_grad[kk] = np.mean(h_eff_grad, axis=1)
+        
+        # Aggregate gradients across samples using sample weights
+        interaction_grad = - np.sum(rec_interaction_grad * samp_weight[:, None, None], axis=0)
+        selfj_grad = - np.sum(rec_selfj_grad * samp_weight[:, None], axis=0)
+        selfh_grad = - np.sum(rec_selfh_grad * samp_weight[:, None], axis=0)
+        
+        if lambda_l1_j > 0:
+            interaction_grad += lambda_l1_j * (cur_interaction / l1_base).clip(- 1, 1)
+        if lambda_l2_j > 0:
+            interaction_grad += lambda_l2_j * cur_interaction
+
+        # Update parameters using the provided update_adam function
+        update_val, m_interaction, v_interaction = update_adam(interaction_grad, m_interaction, v_interaction, counter, stepsz)
+        cur_interaction = cur_interaction - update_val
+        
+        update_val, m_selfj, v_selfj = update_adam(selfj_grad, m_selfj, v_selfj, counter, stepsz)
+        cur_selfj = cur_selfj - update_val
+        
+        update_val, m_selfh, v_selfh = update_adam(selfh_grad, m_selfh, v_selfh, counter, stepsz)
+        cur_selfh = cur_selfh - update_val
+        
+        # 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}"})
+
+        counter += 1
+    
+    return cur_interaction, cur_selfj, cur_selfh
+
+
 def compute_relative_responses(cur_h, if_control, batch_index):
     """
     Compute the relative responses of samples by subtracting the average of control samples.
@@ -831,20 +988,22 @@ def compute_relative_responses(cur_h, if_control, batch_index):
     numpy.ndarray: A 2D array of the same shape as `cur_h`, containing the relative responses for each sample.
     """
     
-    if np.all(if_control == 0):
-        raise ValueError('if_control contains all zeros')
 
     unique_batches = np.unique(batch_index)
     num_batches = len(unique_batches)
 
     relative_h = np.zeros_like(cur_h)
-    all_controls_mean = np.mean(cur_h[:, if_control], axis=1)
+    
+    if np.all(if_control == 0):
+        all_controls_mean = np.mean(cur_h, axis=1)
+    else:
+        all_controls_mean = np.mean(cur_h[:, if_control], axis=1)
     
     for current_batch in unique_batches:
         batch_samples_idx = np.where(batch_index == current_batch)[0]
-        batch_controls_idx = batch_samples_idx[if_control[batch_samples_idx]]
-        
-        if batch_controls_idx.size > 0:
+
+        if np.any(if_control[batch_samples_idx]):
+            batch_controls_idx = batch_samples_idx[if_control[batch_samples_idx]]
             batch_controls_mean = np.mean(cur_h[:, batch_controls_idx], axis=1)
         else:
             batch_controls_mean = all_controls_mean

{dspin-1.1.2 → dspin-1.2.0}/dspin/dspin.py

@@ -4,13 +4,13 @@
 @Author  :   Jialong Jiang, Yingying Gong
 '''
 
-from .plot import (
-    onmf_to_csv
-)
+from .plot import onmf_to_csv
 from .compute import (
     onmf_discretize,
     sample_corr_mean,
+    sample_states,
     learn_network_adam,
+    learn_program_regulators,
     category_balance_number,
     compute_onmf,
     summary_components,
@@ -32,36 +32,22 @@ import networkx as nx
 import matplotlib.patheffects as patheffects
 import warnings
 import itertools
-from typing import List
+from typing import List, Dict, Optional, Tuple, Union
+
 
 
 class AbstractDSPIN(ABC):
     """
-    Parent and abstract class for DSPIN, not to be instantiated directly.
-    Contains methods and properties common to both GeneDSPIN and ProgramDSPIN.
-
-    ...
+    Abstract base class for DSPIN, providing common methods and properties for GeneDSPIN and ProgramDSPIN.
+    
     Attributes
     ----------
     adata : ad.AnnData
-        Annotated data.
+        Annotated single-cell gene expression data.
     save_path : str
-        Path where results will be saved.
+        Directory path where results will be stored.
     num_spin : int
-        Number of spins.
-
-    Methods
-    -------
-    discretize()
-        Discretizes the ONMF representation into three states (-1, 0, 1) using K-means clustering.
-    raw_data_corr(sample_col_name)
-        Computes correlation of raw data based on sample column name.
-    raw_data_state(sample_col_name)
-        Calculate and return the correlation of raw data.
-    default_params(method)
-        Provide the default parameters for the specified algorithm.
-    network_inference(sample_col_name, method, params, example_list, record_step)
-        Execute the network inference using the specified method and parameters and record the results.
+        Number of spins for modeling.
     """
 
     def __init__(self,
@@ -69,12 +55,16 @@ class AbstractDSPIN(ABC):
                  save_path: str,
                  num_spin: int):
         """
-        Initialize the AbstractDSPIN object with specified Annotated Data, save path, and number of spins.
-
-        Parameters:
-        adata (ad.AnnData): Annotated Data.
-        save_path (str): Path where results will be saved.
-        num_spin (int): number of spins.
+        Initialize an instance of AbstractDSPIN.
+
+        Parameters
+        ----------
+        adata : ad.AnnData
+            Annotated data matrix containing observations and gene expressions.
+        save_path : str
+            Directory path for saving results.
+        num_spin : int
+            Number of spins used in DSPIN.
         """
 
         self.adata = adata
@@ -84,15 +74,16 @@ class AbstractDSPIN(ABC):
         if not os.path.exists(self.save_path):
             os.makedirs(self.save_path)
             print("Saving path does not exist. Creating a new folder.")
-        self.fig_folder = self.save_path + 'figs/'
+            
+        self.fig_folder = self.save_path + 'figures/'
         os.makedirs(self.fig_folder, exist_ok=True)
 
     @property
-    def program_representation(self):
+    def program_representation_raw(self):
         return self._onmf_rep_ori
 
     @property
-    def program_discretized(self):
+    def program_representation(self):
         return self._onmf_rep_tri
 
     @property
@@ -115,12 +106,12 @@ class AbstractDSPIN(ABC):
     def sample_list(self):
         return self._samp_list
 
-    @program_representation.setter
-    def program_representation(self, value):
+    @program_representation_raw.setter
+    def program_representation_raw(self, value):
         self._onmf_rep_ori = value
 
-    @program_discretized.setter
-    def program_discretized(self, value):
+    @program_representation.setter
+    def program_representation(self, value):
         self._onmf_rep_tri = value
 
     @network.setter
@@ -139,53 +130,52 @@ class AbstractDSPIN(ABC):
     def sample_list(self, value):
         self._samp_list = value
 
-    def discretize(self) -> np.ndarray:
+    def discretize(self, clip_percentile: float = 100) -> None:
         """
-        Discretizes the ONMF representation into three states (-1, 0, 1) using K-means clustering.
+        Discretizes the oNMF representation into three states (-1, 0, 1) using K-means clustering.
 
-        Returns:
-        - np.ndarray: The discretized ONMF representation.
+        Parameters
+        ----------
+        clip_percentile : float, optional
+            Percentile at which to clip values before discretization (default is 100).
         """
-        onmf_rep_ori = self.program_representation
+        onmf_rep_ori = self.program_representation_raw.copy()
         fig_folder = self.fig_folder
 
+        if clip_percentile < 100:
+            for ii in range(onmf_rep_ori.shape[1]):
+                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)
         self._onmf_rep_tri = onmf_rep_tri
 
-    def raw_data_corr(self, sample_col_name) -> np.ndarray:
+    def raw_data_corr(self, sample_id_key: str) -> None:
         """
-        Computes correlation of raw data based on sample column name.
+        Computes correlation of raw data based on a sample column name.
 
-        :param sample_col_name: The name of the sample column to be used for correlation computation.
-        :return: The correlated raw data.
+        Parameters
+        ----------
+        sample_id_key : str
+            Column name in adata.obs specifying sample identifiers.
         """
-
         raw_data, samp_list = sample_corr_mean(
-            self.adata.obs[sample_col_name], self._onmf_rep_tri)
+            self.adata.obs[sample_id_key], self._onmf_rep_tri)
         self._raw_data = raw_data
         self._samp_list = samp_list
 
-    def raw_data_state(self, sample_col_name) -> np.ndarray:
+    def raw_data_state(self, sample_id_key) -> None:
         """
-        Calculate and return the correlation of raw data.
-
-        Parameters:
-        sample_col_name (str): The name of the column in the sample to calculate the correlation.
+        Compute and return the state of raw data based on sample identifiers.
 
-        Returns:
-        np.ndarray: Array representing the correlated raw data.
+        Parameters
+        ----------
+        sample_id_key : str
+            Column name in `adata.obs` used to group and compute raw data states.
         """
-        cadata = self.adata
-        onmf_rep_tri = self._onmf_rep_tri
-
-        samp_list = np.unique(cadata.obs[sample_col_name])
-        state_list = np.zeros(len(samp_list), dtype=object)
-
-        for ii, cur_samp in enumerate(samp_list):
-            cur_filt = cadata.obs[sample_col_name] == cur_samp
-            cur_state = self._onmf_rep_tri[cur_filt, :]
-            state_list[ii] = cur_state.T
-
+        state_list, samp_list = sample_states(
+            self.adata.obs[sample_id_key], self._onmf_rep_tri)
+        
         self._raw_data = state_list
         self._samp_list = samp_list
 
@@ -194,8 +184,10 @@ class AbstractDSPIN(ABC):
         """
         Provide the default parameters for the specified algorithm.
 
-        Parameters:
-        method (str): The method for which to return the default parameters.
+        Parameters
+        ----------
+        method : str
+            The inference method. Options: 'maximum_likelihood', 'mcmc_maximum_likelihood', 'pseudo_likelihood'.
 
         Returns:
         dict: Dictionary containing default parameters for the specified method.
@@ -215,7 +207,8 @@ class AbstractDSPIN(ABC):
         params = {'num_epoch': 200,
                   'cur_j': np.zeros((num_spin, num_spin)),
                   'cur_h': np.zeros((num_spin, num_sample)),
-                  'save_path': self.save_path}
+                  'save_path': self.save_path, 
+                  'rec_gap': 10}
         params.update({'lambda_l1_j': 0.01,
                        'lambda_l1_h': 0,
                        'lambda_l2_j': 0,
@@ -236,29 +229,32 @@ class AbstractDSPIN(ABC):
         return params
 
     def network_inference(self,
-                          sample_col_name: str = 'sample_id',
+                          sample_id_key: str = 'sample_id',
                           method: str = 'auto',
                           directed: bool = False,
                           params: dict = None,
                           example_list: List[str] = None,
-                          record_step: int = 10,
-                          run_with_matlab: bool = False, 
-                          precomputed_discretization: np.array = None):
+                          run_with_matlab: bool = False) -> None:
         """
-        Execute the network inference using the specified method and parameters and record the results.
-
-        Parameters:
-        sample_col_name (str): The name of the sample column.
-        method (str, optional): The method used for network inference, default is 'auto'.
-        params (dict, optional): Dictionary of parameters to be used, default is None.
-        example_list (List[str], optional): List of examples to be used, default is None.
-        record_step (int, optional): The step interval to record the results, default is 10.
-
-        Raises:
-        ValueError: If an invalid method is specified.
+        Perform network inference using a specified method and parameters.
+
+        Parameters
+        ----------
+        sample_id_key : str, optional
+            Column name in `adata.obs` for sample identifiers. Default is 'sample_id'.
+        method : str, optional
+            The method used for network inference. Options: 'maximum_likelihood', 'mcmc_maximum_likelihood', 'pseudo_likelihood', 'auto'. Default is 'auto'.
+        directed : bool, optional
+            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.
+        run_with_matlab : bool, optional
+            If True, prepares data for MATLAB execution instead of running inference in Python. Default is False.
         """
 
-        self.sample_col_name = sample_col_name
+        self.sample_id_key = sample_id_key
 
         if method not in [
             'maximum_likelihood',
@@ -269,7 +265,7 @@ class AbstractDSPIN(ABC):
                 "Method must be one of 'maximum_likelihood', 'mcmc_maximum_likelihood', 'pseudo_likelihood' or 'auto'.")
 
         if method == 'auto':           
-            samp_list = np.unique(self.adata.obs[sample_col_name])
+            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)
@@ -287,18 +283,14 @@ class AbstractDSPIN(ABC):
 
         print("Using {} for network inference.".format(method))
 
-        if precomputed_discretization is not None:
-            self._onmf_rep_tri = precomputed_discretization
-
         if method == 'pseudo_likelihood':
-            self.raw_data_state(sample_col_name)
+            self.raw_data_state(sample_id_key)
         else:
-            self.raw_data_corr(sample_col_name)
+            self.raw_data_corr(sample_id_key)
 
         self.example_list = example_list
 
         train_dat = self.default_params(method)
-        train_dat['rec_gap'] = record_step
         train_dat['directed'] = directed
         if params is not None:
             train_dat.update(params)
@@ -308,7 +300,7 @@ class AbstractDSPIN(ABC):
             file_path = self.save_path + 'raw_data.mat'
             savemat(file_path, {'raw_data': self._raw_data, 'sample_list': self._samp_list, 
             'method': method, 'directed': directed, **train_dat})
-            print("Data saved to {}. Please run the network inference in MATLAB and load the results back.".format(file_path))
+            print("Data saved to {}. Please run the network inference in MATLAB".format(file_path))
 
         else:
             cur_j, cur_h, train_log = learn_network_adam(self.raw_data, method, train_dat)
@@ -317,80 +309,131 @@ class AbstractDSPIN(ABC):
             self.train_log = train_log
 
     def response_relative_to_control(self, 
-                           if_control: np.array, 
-                           batch_index: np.array):
+                           sample_id_key: str = 'sample_id',
+                           if_control_key: str = 'if_control', 
+                           batch_key: str = 'batch'):
         """
-        Compute the relative responses based on the control samples in each batch or all batches.
-
-        Parameters:
-        if_control (numpy.ndarray): A boolean array indicating which samples are control samples.
-        batch_index (numpy.ndarray): An array indicating the batch assignment for each sample.
+        Compute the relative responses based on control samples in each batch.
+
+        Parameters
+        ----------
+        sample_id_key : str, optional
+            Column name in `adata.obs` specifying sample identifiers. Default is 'sample_id'.
+        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'.
         """
 
+        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)[if_control_key].first().to_dict()
+        sample_to_batch = self.adata.obs.groupby(sample_id_key)[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])
+
         self._relative_responses = compute_relative_responses(self.responses, if_control, batch_index)
 
 
 class GeneDSPIN(AbstractDSPIN):
     """
-    GeneDSPIN inherits the AbstractDSPIN class, optimized for handling smaller datasets.
-    It doesn't need ONMF and can directly perform network inference on the genes.
+    GeneDSPIN inherits the AbstractDSPIN class, optimized for building gene-level networks.
+    It doesn't need oNMF and can directly perform network inference on the genes.
     """
 
     def __init__(self,
                  adata: ad.AnnData,
                  save_path: str,
-                 num_spin: int):
+                 num_spin: int,
+                 clip_percentile: float = 95):
         """
         Initialize the GeneDSPIN object.
 
-        Parameters:
-        adata (ad.AnnData): annotated data, contains observed data with annotations.
-        save_path (str): Path where results will be saved.
-        num_spin (int): Specifies the number of spins.
+        Parameters
+        ----------
+        adata : ad.AnnData
+            Annotated single-cell gene expression data.
+        save_path : str
+            Directory path where results will be saved.
+        num_spin : int
+            Number of spins used in inference.
+        clip_percentile : float, optional
+            Percentile threshold for clipping values before discretization. Default is 95.
         """
 
         super().__init__(adata, save_path, num_spin)
         print("GeneDSPIN initialized.")
 
         if issparse(adata.X):
-            self._onmf_rep_ori = np.array(adata.X)
+            self._onmf_rep_ori = adata.X.toarray()
         else:
             self._onmf_rep_ori = adata.X
 
-        self.discretize()
+        self.discretize(clip_percentile)
+
+    def program_regulator_discovery(self, 
+                                    program_representation_raw: np.ndarray, 
+                                    sample_id_key: str = 'sample_id',
+                                    params: dict = None):
+        """
+        Discover regulators of given gene programs using regression.
+
+        Parameters
+        ----------
+        program_representation_raw : np.ndarray
+            The gene program representation.
+        sample_id_key : str, optional
+            Column name in `adata.obs` specifying sample identifiers. Default is 'sample_id'.
+        params : dict, optional
+            Additional parameters for regression. Default is None.
+        """
+
+        program_states, samp_list = sample_states(self.adata.obs[sample_id_key], program_representation_raw)
+
+        gene_states, _ = sample_states(self.adata.obs[sample_id_key], self._onmf_rep_tri)
+
+        train_dat = {
+            'num_epoch': 500,
+            'stepsz': 0.01,
+            'lambda_l1_interaction': 0.01,
+            'rec_gap': 10
+        }
+
+        if params is not None:
+            train_dat.update(params)
+
+        cur_interaction, cur_selfj, cur_selfh = learn_program_regulators(gene_states, program_states, train_dat)
+
+        self.program_interactions = cur_interaction
+        self.program_activities = cur_selfh
+        self.program_self_interactions = cur_selfj
+        
 
 
 class ProgramDSPIN(AbstractDSPIN):
     """
-    ProgramDSPIN inherits the AbstractDSPIN class, optimized for handling larger datasets.
-    It contains specialized methods to handle subsampling and balancing of large gene matrices.
+    ProgramDSPIN extends AbstractDSPIN to handle large datasets efficiently.
+    This class includes methods for subsampling, balancing gene matrices, and running repeated oNMF decompositions.
 
-    ...
     Attributes
     ----------
     adata : ad.AnnData
-        Annotated data.
+        Annotated single-cell gene expression data.
     save_path : str
-        Path where results will be saved.
+        Directory path where results will be stored.
     num_spin : int
-        Number of spins.
-    num_onmf_components : int
-        Number of ONMF components.
-    preprograms : List[List[str]]
-        List of preprograms.
-    num_repeat : int
-        Number of times to repeat ONMF.
-
-    Methods
-    -------
-    subsample_matrix_balance(total_sample_size, std_clip_percentile)
-        Subsample and balance a gene matrix to achieve the desired sample size and standard deviation clipping percentile.
-    compute_onmf_repeats(num_onmf_components, num_repeat, num_subsample, seed, std_clip_percentile)
-        Compute ONMF decompositions repeatedly after subsampling of the gene matrix for each repetition.
-    summarize_onmf_result(num_onmf_components, num_repeat, summary_method)
-        Summarize the results of the repeated ONMF decompositions, integrating the components obtained from each ONMF decomposition and preprograms if provided.
-    gene_program_discovery(num_onmf_components, num_subsample, num_subsample_large, num_repeat, balance_obs, balance_method, max_sample_rate, prior_programs, summary_method)
-        Discovers gene programs by performing ONMF decomposition on the given annotated data object.
+        Number of spins used in modeling.
+    num_onmf_components : int, optional
+        Number of oNMF components.
+    prior_programs : List[List[str]], optional
+        List of predefined gene programs.
+    num_repeat : int, optional
+        Number of oNMF repetitions for stability.
     """
 
     def __init__(self,
@@ -398,18 +441,25 @@ class ProgramDSPIN(AbstractDSPIN):
                  save_path: str,
                  num_spin: int,
                  num_onmf_components: int = None,
-                 preprograms: List[List[str]] = None,
+                 prior_programs: List[List[str]] = None,
                  num_repeat: int = 10):
         """
         Initialize the ProgramDSPIN object.
 
-        Parameters:
-        adata (ad.AnnData): An annotated data matrix, contains observed data with annotations.
-        save_path (str): Path where results will be saved.
-        num_spin (int): Specifies the number of spins.
-        num_onmf_components (int, optional): The number of ONMF components, default is None.
-        preprograms (List[List[str]], optional): List of preprograms, default is None.
-        num_repeat (int, optional): The number of times to repeat, default is 10.
+        Parameters
+        ----------
+        adata : ad.AnnData
+            Annotated data matrix containing observations and gene expressions.
+        save_path : str
+            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)
 
@@ -419,8 +469,8 @@ class ProgramDSPIN(AbstractDSPIN):
         self._gene_matrix_large = None
         self._use_data_list = None
         self.gene_program_csv = None
-        self.preprograms = None
-        self.preprogram_num = len(preprograms) if preprograms else 0
+        self.prior_programs = None
+        self.preprogram_num = len(prior_programs) if prior_programs else 0
 
     @property
     def onmf_decomposition(self):
@@ -432,20 +482,21 @@ class ProgramDSPIN(AbstractDSPIN):
 
     def subsample_matrix_balance(self,
                                  total_sample_size: int,
-                                 std_clip_percentile: float = 20) -> (np.ndarray,
-                                                                      np.ndarray):
+                                 std_clip_percentile: float = 20) -> Tuple[np.ndarray, np.ndarray]:
         """
-        Subsample and balance a gene matrix to achieve the desired sample size and
-        standard deviation clipping percentile.
-
-        Parameters:
-        total_sample_size (int): The desired sample size after subsampling.
-        std_clip_percentile (float, optional): The desired percentile for standard deviation clipping,
-                                               default is 20.
-
-        Returns:
-        Tuple[np.ndarray, np.ndarray]: A tuple containing the clipped standard deviations
-                                       and the balanced and normalized gene matrix.
+        Subsample and balance the gene matrix based on desired sample size and standard deviation clipping.
+
+        Parameters
+        ----------
+        total_sample_size : int
+            The target number of cells after subsampling.
+        std_clip_percentile : float, optional
+            Percentile for standard deviation clipping, default is 20.
+
+        Returns
+        -------
+        Tuple[np.ndarray, np.ndarray]
+            Clipped standard deviations and the balanced, normalized gene matrix.
         """
         gene_matrix = self.adata.X
         cadata = self.adata
@@ -476,17 +527,14 @@ class ProgramDSPIN(AbstractDSPIN):
                 strart_ind = np.sum(sampling_number[:ii])
                 end_ind = strart_ind + cur_num
                 if issparse(cadata.X):
-                    gene_matrix_balanced[strart_ind: end_ind,
-                                         :] = cadata.X[cur_filt,
-                                                       :][sele_ind,
-                                                          :].toarray()
+                    gene_matrix_balanced[strart_ind: end_ind, :] = cadata.X[cur_filt, :][sele_ind, :].toarray()
                 else:
-                    gene_matrix_balanced[strart_ind: end_ind,
-                                         :] = cadata.X[cur_filt, :][sele_ind, :]
+                    gene_matrix_balanced[strart_ind: end_ind, :] = cadata.X[cur_filt, :][sele_ind, :]
 
         # Normalize the matrix by standard deviation
         if issparse(gene_matrix_balanced):
             gene_matrix_balanced = np.asarray(gene_matrix_balanced.toarray())
+
         std = gene_matrix_balanced.std(axis=0)
         std_clipped = std.clip(np.percentile(std, std_clip_percentile), np.inf)
         gene_matrix_balanced_normalized = gene_matrix_balanced / std_clipped
@@ -498,42 +546,48 @@ class ProgramDSPIN(AbstractDSPIN):
                              num_repeat: int,
                              num_subsample: int,
                              seed: int = 0,
-                             std_clip_percentile: float = 20):
+                             std_clip_percentile: float = 20) -> None:
         """
-        Compute ONMF decompositions repeatedly after subsampling of the gene matrix for each repetition.
-
-        Parameters:
-        num_onmf_components (int): The number of ONMF components.
-        num_repeat (int): The number of times to repeat the ONMF computation.
-        num_subsample (int): The number of samples to obtain after subsampling.
-        seed (int, optional): Seed for reproducibility. Default is 0.
-        std_clip_percentile (float, optional): Percentile for standard deviation clipping. Default is 20.
+        Perform multiple oNMF decompositions on subsampled data to enhance stability.
+
+        Parameters
+        ----------
+        num_onmf_components : int
+            Number of oNMF components.
+        num_repeat : int
+            Number of repetitions for oNMF computation.
+        num_subsample : int
+            Number of cells to use while computing the oNMF
+        seed : int, optional
+            Seed for reproducibility. Default is 0.
+        std_clip_percentile : float, optional
+            Percentile for standard deviation clipping. Default is 20.
         """
 
-        preprograms = self.prior_programs
+        prior_programs = self.prior_programs
         adata = self.adata
         
-        # Create the directory for saving ONMF decompositions if it doesn't
+        # Create the directory for saving oNMF decompositions if it doesn't
         # exist
         os.makedirs(self.save_path + 'onmf/', exist_ok=True)
 
-        print("Computing ONMF decomposition...")
+        print("Computing oNMF decomposition...")
 
-        # Repeat ONMF decomposition for num_repeat times
+        # Repeat oNMF decomposition for num_repeat times
         for ii in range(num_repeat):
             np.random.seed(seed + ii)
-            # Check if ONMF decomposition for the current iteration exists
+            # Check if oNMF decomposition for the current iteration exists
             if os.path.exists(
                     self.save_path + 'onmf/onmf_rep_{}_{}.npy'.format(num_onmf_components, ii)):
                 print(
-                    "ONMF decomposition {} already exists. Skipping...".format(ii))
+                    "oNMF decomposition {} already exists. Skipping...".format(ii))
                 continue
 
             # Subsample the matrix and normalize it
             _, gene_matrix_norm = self.subsample_matrix_balance(
                 num_subsample, std_clip_percentile=std_clip_percentile)
 
-            # Compute current ONMF decomposition and save the result
+            # Compute current oNMF decomposition and save the result
             current_onmf = compute_onmf(
                 seed + ii, num_onmf_components, gene_matrix_norm[:, self.prior_programs_mask])
             np.save(self.save_path +
@@ -542,18 +596,24 @@ class ProgramDSPIN(AbstractDSPIN):
     def summarize_onmf_result(self,
                               num_onmf_components: int,
                               num_repeat: int,
-                              summary_method: str):
+                              summary_method: str) -> NMF:
         """
-        Summarize the results of the repeated ONMF decompositions,
-        integrating the components obtained from each ONMF decomposition and preprograms if provided.
-
-        Parameters:
-        num_onmf_components (int): The number of ONMF components.
-        num_repeat (int): The number of repetitions for ONMF computation.
-        summary_method (str): The method used for summarizing the components.
-
-        Returns:
-        object: An NMF object containing the summarized components.
+        Summarize the results of repeated oNMF decompositions,
+        integrating components from each oNMF run and prior programs if available.
+
+        Parameters
+        ----------
+        num_onmf_components : int
+            Number of oNMF components.
+        num_repeat : int
+            Number of oNMF repetitions.
+        summary_method : str
+            The method used for summarizing oNMF components.
+
+        Returns
+        -------
+        NMF
+            An NMF object containing the summarized components.
         """
 
         # Retrieve the number of spins and annotated data
@@ -567,14 +627,11 @@ class ProgramDSPIN(AbstractDSPIN):
         for ii in range(num_repeat):
             cur_onmf = np.load(
                 self.save_path +
-                'onmf/onmf_rep_{}_{}.npy'.format(
-                    num_onmf_components,
-                    ii),
+                'onmf/onmf_rep_{}_{}.npy'.format(num_onmf_components, ii),
                 allow_pickle=True).item()
             rec_components[ii] = cur_onmf.components_
 
-        all_components = rec_components.reshape(-1,
-                                                np.sum(prior_programs_mask))
+        all_components = rec_components.reshape(-1, np.sum(prior_programs_mask))
 
         gene_group_ind = summary_components(
             all_components,
@@ -620,23 +677,30 @@ class ProgramDSPIN(AbstractDSPIN):
                                prior_programs: List[List[str]] = None,
                                summary_method: str = 'kmeans'):
         """
-        Discovers gene programs by performing ONMF decomposition on the given annotated data object.
-
-        Parameters:
-        num_onmf_components (int, optional): The number of ONMF components. Default is None.
-        num_subsample (int, optional): Number of samples to obtain 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 the ONMF computation. Default is 10.
-        balance_obs (str, optional): Observation to balance. Default is None.
-        balance_method (str, optional): Method used for balancing. Default is None.
-        max_sample_rate (float, optional): Maximum sample rate. Default is 2.
-        prior_programs (List[List[str]], optional): List of prior programs. Default is None.
-        summary_method (str, optional): Method used for summarizing the components. Default is 'kmeans'.
-
-        Raises:
-        ValueError: If balance_method is not one of equal, proportional, squareroot, or None
-        ValueError: If summary_method is not one of kmeans or leiden
-        ValueError: If the number of prior_programs is greater than the number of spins
+        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.
+        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'.
         """
 
         if balance_method not in ['equal', 'proportional', 'squareroot', None]:
@@ -671,7 +735,7 @@ class ProgramDSPIN(AbstractDSPIN):
                 gene for program in prior_programs for gene in program]
             if len(prior_programs) > num_spin:
                 raise ValueError(
-                    'Number of preprograms must be less than the number of spins')
+                    'Number of prior_programs must be less than the number of spins')
 
             # Generate mask to exclude genes in prior programs from the
             # annotated data
@@ -680,7 +744,7 @@ class ProgramDSPIN(AbstractDSPIN):
             prior_program_mask = np.ones(adata.shape[1], dtype=bool)
             prior_program_ind = []
 
-        # number of ONMF components = number of spins - number of prior
+        # number of oNMF components = number of spins - number of prior
         # programs
         if num_onmf_components is None:
             num_onmf_components = self.num_spin - len(prior_program_ind)
@@ -693,7 +757,7 @@ class ProgramDSPIN(AbstractDSPIN):
         self.matrix_std, self.large_subsample_matrix = self.subsample_matrix_balance(
             num_subsample_large, std_clip_percentile=20)
 
-        # Compute ONMF decompositions repeatedly
+        # Compute oNMF decompositions repeatedly
         self.compute_onmf_repeats(
             num_onmf_components,
             num_repeat,
@@ -701,7 +765,7 @@ class ProgramDSPIN(AbstractDSPIN):
             seed,
             std_clip_percentile=20)
 
-        # Summarize the ONMF decompositions
+        # Summarize the oNMF decompositions
         onmf_summary = self.summarize_onmf_result(
             num_onmf_components, num_repeat, summary_method)
         self._onmf_summary = onmf_summary
@@ -722,7 +786,7 @@ class ProgramDSPIN(AbstractDSPIN):
         gene_matrix = self.adata.X
         if issparse(gene_matrix):
             gene_matrix = np.asarray(gene_matrix.toarray()).astype(np.float64)
-        # Transform the original matrix by the ONMF summary components and
+        # Transform the original matrix by the oNMF summary components and
         # normalize by standard deviation
         self._onmf_rep_ori = onmf_summary.transform(
             gene_matrix / self.matrix_std)
@@ -732,11 +796,8 @@ class ProgramDSPIN(AbstractDSPIN):
 
 class DSPIN(object):
     """
-    DSPIN class client end.
-
-    This class serves as a automatic conditional constructor to decide
-    which subclass of DSPIN to instantiate based on the number of genes
-    and spins provided.
+    DSPIN class determines the appropriate subclass (GeneDSPIN or ProgramDSPIN)
+    based on the dataset's gene count and spin count.
     """
 
     def __new__(cls,
@@ -744,32 +805,40 @@ class DSPIN(object):
                 save_path: str,
                 num_spin: int = None,
                 filter_threshold: float = 0.02,
-                **kwargs):
+                **kwargs) -> Union[GeneDSPIN, ProgramDSPIN]:
         """
-        Initialize the DSPIN object.
-
-        Parameters:
-        adata (ad.AnnData): The annotated data of shape n_cells x n_genes.
-        save_path (str): The path to save any output or results.
-        num_spin (int, optional): The number of spins. Defaults to 15.
-        filter_threshold (float, optional): The threshold to filter genes. Defaults to 0.02.
-        **kwargs: Keyword arguments, see classes GeneDSPIN and ProgramDSPIN for more details.
-
-        Returns:
-        DSPIN object: An instance of either GeneDSPIN or ProgramDSPIN subclass.
+        Initialize DSPIN and select the appropriate subclass.
+
+        Parameters
+        ----------
+        adata : ad.AnnData
+            The annotated data matrix (n_cells x n_genes).
+        save_path : str
+            Path to save results.
+        num_spin : int, optional
+            Number of spins for network inference. Default is 15 or number of genes if lower.
+        filter_threshold : float, optional
+            Minimum fraction of cells expressing a gene for it to be retained. Default is 0.02.
+        **kwargs : dict
+            Additional keyword arguments passed to the selected subclass.
+
+        Returns
+        -------
+        Union[GeneDSPIN, ProgramDSPIN]
+            An instance of either GeneDSPIN or ProgramDSPIN based on gene count.
         """
 
+        if adata.X.min() < 0:
+            warnings.warn("Negative expression detected. Expect normalized log-transformed data.")
+
         # Filtering genes based on the filter_threshold.
-        # It retains only those genes that have expression
-        # in more than the specified percentage of cells.
         sc.pp.filter_genes(adata, min_cells=adata.shape[0] * filter_threshold)
         print(
             '{} genes have expression in more than {} of the cells'.format(
                 adata.shape[1],
                 filter_threshold))
 
-        # if the number of genes is less than the number of spins, use
-        # GeneDSPIN
+        # if the number of genes is less than the number of spins, use GeneDSPIN
         if num_spin is None:
             num_spin = np.min([15, adata.shape[1]])
 

{dspin-1.1.2 → dspin-1.2.0/dspin.egg-info}/PKG-INFO

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

{dspin-1.1.2 → dspin-1.2.0}/setup.py

@@ -21,7 +21,7 @@ install_requires = [
 # ]
 
 # Managing your version (adjust accordingly)
-version = "1.1.2"  # You can manage versioning in a more sophisticated way if needed
+version = "1.2.0"  # 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